@yanhaidao/wecom 2.3.4 → 2.3.9

package/src/capability/bot/stream-orchestrator.ts

@@ -0,0 +1,352 @@
+import { pathToFileURL } from "node:url";
+
+import type { PluginRuntime } from "openclaw/plugin-sdk";
+
+import { resolveWecomMediaMaxBytes, shouldRejectWecomDefaultRoute } from "../../config/index.js";
+import { ensureDynamicAgentListed, generateAgentId, shouldUseDynamicAgent } from "../../dynamic-agent.js";
+import { LIMITS, type StreamStore } from "../../monitor/state.js";
+import { getWecomRuntime } from "../../runtime.js";
+import { buildWecomUnauthorizedCommandPrompt, resolveWecomCommandAuthorization } from "../../shared/command-auth.js";
+import type { PendingInbound } from "../../types/legacy-stream.js";
+import type { WecomBotInboundMessage as WecomInboundMessage } from "../../types/index.js";
+import type { WecomWebhookTarget } from "../../types/runtime-context.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 { createBotReplyDispatcher } from "./stream-delivery.js";
+import type { BotRuntimeLogger, RecordBotOperationalEvent } from "./types.js";
+
+export type StartBotAgentStreamParams = {
+  target: WecomWebhookTarget;
+  accountId: string;
+  msg: WecomInboundMessage;
+  streamId: string;
+  mergedContents?: string[] | string;
+  mergedMsgids?: string[];
+};
+
+export function createBotStreamOrchestrator(params: {
+  streamStore: StreamStore;
+  recordBotOperationalEvent: RecordBotOperationalEvent;
+}) {
+  const { streamStore, recordBotOperationalEvent } = params;
+
+  const logVerbose: BotRuntimeLogger = (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: BotRuntimeLogger = (target, message) => {
+    target.runtime.log?.(`[wecom] ${message}`);
+  };
+
+  const truncateUtf8Bytes = (text: string, maxBytes: number): string => {
+    const buf = Buffer.from(text, "utf8");
+    if (buf.length <= maxBytes) return text;
+    return buf.subarray(buf.length - maxBytes).toString("utf8");
+  };
+
+  const computeTaskKey = (target: WecomWebhookTarget, msg: WecomInboundMessage): string | undefined => {
+    const msgid = msg.msgid ? String(msg.msgid) : "";
+    if (!msgid) return undefined;
+    const aibotid = String((msg as any).aibotid ?? "unknown").trim() || "unknown";
+    return `bot:${target.account.accountId}:${aibotid}:${msgid}`;
+  };
+
+  async function flushPending(pending: PendingInbound): Promise<void> {
+    const { streamId, target, msg, contents, msgids, conversationKey, batchKey } = pending;
+    const mergedContents = contents.filter((c) => c.trim()).join("\n").trim();
+
+    let core: PluginRuntime | null = 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: WecomWebhookTarget = { ...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: StartBotAgentStreamParams): Promise<void> {
+    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 as any).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: string | undefined;
+    let mediaType: string | undefined;
+    if (media) {
+      try {
+        const maxBytes = resolveWecomMediaMaxBytes(target.config);
+        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}`);
+    }
+
+    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:${userId}`,
+      To: `wecom:${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: `wecom:${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/src/capability/bot/types.ts

@@ -0,0 +1,8 @@
+import type { WecomRuntimeAuditEvent, WecomWebhookTarget } from "../../types/runtime-context.js";
+
+export type BotRuntimeLogger = (target: WecomWebhookTarget, message: string) => void;
+
+export type RecordBotOperationalEvent = (
+  target: Pick<WecomWebhookTarget, "account" | "auditSink">,
+  event: Omit<WecomRuntimeAuditEvent, "transport">,
+) => void;

package/src/capability/index.ts

@@ -0,0 +1,2 @@
+export { WecomBotCapabilityService } from "./bot/index.js";
+export { WecomAgentIngressService } from "./agent/index.js";

package/src/channel.lifecycle.test.ts

@@ -89,7 +89,7 @@ function createCtx(params: {
   };
 }
 
-function createLegacyBotConfig(params: {
+function createWebhookBotConfig(params: {
   token: string;
   encodingAESKey: string;
   receiveId?: string;
@@ -99,9 +99,12 @@ function createLegacyBotConfig(params: {
       wecom: {
         enabled: true,
         bot: {
-          token: params.token,
-          encodingAESKey: params.encodingAESKey,
-          receiveId: params.receiveId ?? "",
+          primaryTransport: "webhook",
+          webhook: {
+            token: params.token,
+            encodingAESKey: params.encodingAESKey,
+            receiveId: params.receiveId ?? "",
+          },
         },
       },
     },
@@ -148,7 +151,7 @@ describe("wecomPlugin gateway lifecycle", () => {
   it("keeps startAccount pending until abort signal", async () => {
     const token = "token";
     const encodingAESKey = "abcdefghijklmnopqrstuvwxyz0123456789ABCDEFG";
-    const cfg = createLegacyBotConfig({ token, encodingAESKey });
+    const cfg = createWebhookBotConfig({ token, encodingAESKey });
     const abortController = new AbortController();
     const ctx = createCtx({ cfg, abortController });
 
@@ -171,7 +174,7 @@ describe("wecomPlugin gateway lifecycle", () => {
     const token = "token";
     const encodingAESKey = "abcdefghijklmnopqrstuvwxyz0123456789ABCDEFG";
     const receiveId = "";
-    const cfg = createLegacyBotConfig({ token, encodingAESKey, receiveId });
+    const cfg = createWebhookBotConfig({ token, encodingAESKey, receiveId });
     const abortController = new AbortController();
     const ctx = createCtx({ cfg, abortController });
 

package/src/channel.meta.test.ts

@@ -0,0 +1,12 @@
+import { describe, expect, it } from "vitest";
+import { wecomPlugin } from "./channel.js";
+
+describe("wecomPlugin meta", () => {
+  it("uses chinese-facing labels in channel selection", () => {
+    expect(wecomPlugin.meta.label).toBe("WeCom (企业微信)");
+    expect(wecomPlugin.meta.selectionLabel).toBe("WeCom (企业微信)");
+    expect(wecomPlugin.meta.blurb).toContain("企业微信官方推荐三方插件");
+    expect(wecomPlugin.meta.docsLabel).toBe("企业微信");
+    expect(wecomPlugin.meta.selectionDocsPrefix).toBe("文档：");
+  });
+});

package/src/channel.ts

@@ -11,6 +11,7 @@ import {
 import {
   DEFAULT_ACCOUNT_ID,
   listWecomAccountIds,
+  resolveDerivedPathSummary,
   resolveDefaultWecomAccountId,
   resolveWecomAccount,
   resolveWecomAccountConflict,
@@ -19,24 +20,38 @@ import type { ResolvedWecomAccount } from "./types/index.js";
 import { monitorWecomProvider } from "./gateway-monitor.js";
 import { wecomOnboardingAdapter } from "./onboarding.js";
 import { wecomOutbound } from "./outbound.js";
-import { WEBHOOK_PATHS } from "./types/constants.js";
 
 const meta = {
   id: "wecom",
-  label: "WeCom",
-  selectionLabel: "WeCom (plugin)",
+  label: "WeCom (企业微信)",
+  selectionLabel: "WeCom (企业微信)",
   docsPath: "/channels/wecom",
-  docsLabel: "wecom",
-  blurb: "Enterprise WeCom intelligent bot (API mode) via encrypted webhooks + passive replies.",
+  docsLabel: "企业微信",
+  blurb: "企业微信官方推荐三方插件，默认 Bot WS 配置简单，支持主动发消息与 Agent 全能力。",
+  selectionDocsPrefix: "文档：",
   aliases: ["wechatwork", "wework", "qywx", "企微", "企业微信"],
   order: 85,
   quickstartAllowFrom: true,
 };
 
+function resolveAccountInboundPath(account: ResolvedWecomAccount): string | undefined {
+  const derivedPaths = resolveDerivedPathSummary(account.accountId);
+  if (account.bot?.primaryTransport === "webhook" && account.bot.webhookConfigured) {
+    return derivedPaths.botWebhook[0];
+  }
+  if (account.agent?.callbackConfigured) {
+    return derivedPaths.agentCallback[0];
+  }
+  return undefined;
+}
+
 function normalizeWecomMessagingTarget(raw: string): string | undefined {
   const trimmed = raw.trim();
   if (!trimmed) return undefined;
-  return trimmed.replace(/^(wecom-agent|wecom|wechatwork|wework|qywx):/i, "").trim() || undefined;
+  if (/^wecom-agent:/i.test(trimmed)) {
+    return trimmed;
+  }
+  return trimmed.replace(/^(wecom|wechatwork|wework|qywx):/i, "").trim() || undefined;
 }
 
 export const wecomPlugin: ChannelPlugin<ResolvedWecomAccount> = {
@@ -98,7 +113,6 @@ export const wecomPlugin: ChannelPlugin<ResolvedWecomAccount> = {
         accountId: account.accountId,
       })?.message ?? "not configured",
     describeAccount: (account, cfg): ChannelAccountSnapshot => {
-      const matrixMode = account.accountId !== DEFAULT_ACCOUNT_ID;
       const conflict = resolveWecomAccountConflict({
         cfg: cfg as OpenClawConfig,
         accountId: account.accountId,
@@ -108,11 +122,7 @@ export const wecomPlugin: ChannelPlugin<ResolvedWecomAccount> = {
         name: account.name,
         enabled: account.enabled,
         configured: account.configured && !conflict,
-        webhookPath: account.bot?.config
-          ? (matrixMode ? `${WEBHOOK_PATHS.BOT_PLUGIN}/${account.accountId}` : WEBHOOK_PATHS.BOT_PLUGIN)
-          : account.agent?.config
-            ? (matrixMode ? `${WEBHOOK_PATHS.AGENT_PLUGIN}/${account.accountId}` : WEBHOOK_PATHS.AGENT_PLUGIN)
-            : WEBHOOK_PATHS.BOT_PLUGIN,
+        webhookPath: resolveAccountInboundPath(account),
       };
     },
     resolveAllowFrom: ({ cfg, accountId }) => {
@@ -157,11 +167,23 @@ export const wecomPlugin: ChannelPlugin<ResolvedWecomAccount> = {
       configured: snapshot.configured ?? false,
       running: snapshot.running ?? false,
       webhookPath: snapshot.webhookPath ?? null,
+      transport: (snapshot as { transport?: string }).transport ?? null,
+      ownerId: (snapshot as { ownerId?: string }).ownerId ?? null,
+      health: (snapshot as { health?: string }).health ?? "idle",
+      ownerDriftAt: (snapshot as { ownerDriftAt?: number | null }).ownerDriftAt ?? null,
+      connected: (snapshot as { connected?: boolean }).connected,
+      authenticated: (snapshot as { authenticated?: boolean }).authenticated,
       lastStartAt: snapshot.lastStartAt ?? null,
       lastStopAt: snapshot.lastStopAt ?? null,
       lastError: snapshot.lastError ?? null,
+      lastErrorAt: (snapshot as { lastErrorAt?: number | null }).lastErrorAt ?? null,
       lastInboundAt: snapshot.lastInboundAt ?? null,
       lastOutboundAt: snapshot.lastOutboundAt ?? null,
+      recentInboundSummary: (snapshot as { recentInboundSummary?: string | null }).recentInboundSummary ?? null,
+      recentOutboundSummary: (snapshot as { recentOutboundSummary?: string | null }).recentOutboundSummary ?? null,
+      recentIssueCategory: (snapshot as { recentIssueCategory?: string | null }).recentIssueCategory ?? null,
+      recentIssueSummary: (snapshot as { recentIssueSummary?: string | null }).recentIssueSummary ?? null,
+      transportSessions: (snapshot as { transportSessions?: string[] }).transportSessions ?? [],
       probe: snapshot.probe,
       lastProbeAt: snapshot.lastProbeAt ?? null,
     }),
@@ -176,21 +198,26 @@ export const wecomPlugin: ChannelPlugin<ResolvedWecomAccount> = {
         name: account.name,
         enabled: account.enabled,
         configured: account.configured && !conflict,
-        webhookPath: account.bot?.config
-          ? (account.accountId === DEFAULT_ACCOUNT_ID
-              ? WEBHOOK_PATHS.BOT_PLUGIN
-              : `${WEBHOOK_PATHS.BOT_PLUGIN}/${account.accountId}`)
-          : account.agent?.config
-            ? (account.accountId === DEFAULT_ACCOUNT_ID
-                ? WEBHOOK_PATHS.AGENT_PLUGIN
-                : `${WEBHOOK_PATHS.AGENT_PLUGIN}/${account.accountId}`)
-            : WEBHOOK_PATHS.BOT_PLUGIN,
+        webhookPath: resolveAccountInboundPath(account),
+        primaryTransport: account.bot?.primaryTransport ?? (account.agent ? "agent-callback" : null),
+        transport: (runtime as { transport?: string } | undefined)?.transport ?? null,
+        ownerId: (runtime as { ownerId?: string } | undefined)?.ownerId ?? null,
+        health: (runtime as { health?: string } | undefined)?.health ?? "idle",
+        ownerDriftAt: (runtime as { ownerDriftAt?: number | null } | undefined)?.ownerDriftAt ?? null,
+        connected: (runtime as { connected?: boolean } | undefined)?.connected,
+        authenticated: (runtime as { authenticated?: boolean } | undefined)?.authenticated,
         running: runtime?.running ?? false,
         lastStartAt: runtime?.lastStartAt ?? null,
         lastStopAt: runtime?.lastStopAt ?? null,
         lastError: runtime?.lastError ?? conflict?.message ?? null,
+        lastErrorAt: (runtime as { lastErrorAt?: number | null } | undefined)?.lastErrorAt ?? null,
         lastInboundAt: runtime?.lastInboundAt ?? null,
         lastOutboundAt: runtime?.lastOutboundAt ?? null,
+        recentInboundSummary: (runtime as { recentInboundSummary?: string | null } | undefined)?.recentInboundSummary ?? null,
+        recentOutboundSummary: (runtime as { recentOutboundSummary?: string | null } | undefined)?.recentOutboundSummary ?? null,
+        recentIssueCategory: (runtime as { recentIssueCategory?: string | null } | undefined)?.recentIssueCategory ?? null,
+        recentIssueSummary: (runtime as { recentIssueSummary?: string | null } | undefined)?.recentIssueSummary ?? null,
+        transportSessions: (runtime as { transportSessions?: string[] } | undefined)?.transportSessions ?? [],
         dmPolicy: account.bot?.config.dm?.policy ?? "pairing",
       };
     },