@downcity/plugins 1.0.4

package/src/chat/runtime/ChatSessionContextComposer.ts

@@ -0,0 +1,106 @@
+/**
+ * ChatSessionContextComposer：chat 专用 context composer。
+ *
+ * 关键点（中文）
+ * - 由 chat 层在 Session 实例化时注入，不再依赖 run 时层层传 callback。
+ * - step 合并消息读取自 ChatSession 当前绑定的 turn context。
+ * - 其余能力（tools / fallback assistant）继续复用默认本地实现。
+ */
+
+import type { ModelMessage, Tool } from "ai";
+import { drainInjectedUserMessages } from "@downcity/agent/internal/executor/SessionRunScope.js";
+import { LocalSessionContextComposer } from "@downcity/agent/internal/executor/composer/context/LocalSessionContextComposer.js";
+import type { SessionMessageV1 } from "@downcity/agent/internal/executor/types/SessionMessages.js";
+import type { SessionSystemMessage } from "@downcity/agent/internal/executor/types/SessionPrompts.js";
+import type { ChatSessionTurnState } from "@/chat/runtime/ChatSessionTypes.js";
+
+type ChatSessionContextComposerOptions = {
+  /**
+   * 当前 session 标识。
+   */
+  sessionId: string;
+
+  /**
+   * 读取当前可用工具集合。
+   */
+  getTools: () => Record<string, Tool>;
+
+  /**
+   * 读取当前已绑定的 chat turn 状态。
+   */
+  getTurnState: () => ChatSessionTurnState | null;
+};
+
+/**
+ * ChatSession 专用 context composer。
+ */
+export class ChatSessionContextComposer extends LocalSessionContextComposer {
+  private readonly getTurnState: ChatSessionContextComposerOptions["getTurnState"];
+
+  constructor(options: ChatSessionContextComposerOptions) {
+    super({
+      sessionId: options.sessionId,
+      getTools: options.getTools,
+    });
+    this.getTurnState = options.getTurnState;
+  }
+
+  createPrepareStepHandler(
+    input: {
+      system: SessionSystemMessage[];
+      appendMergedUserMessages: (
+        messages: SessionMessageV1[],
+      ) => Promise<ModelMessage[]>;
+    },
+  ): (input: { messages?: ModelMessage[] }) => Promise<{
+    system: SessionSystemMessage[];
+    messages?: ModelMessage[];
+  }> {
+    return async ({
+      messages,
+    }: {
+      messages?: ModelMessage[];
+    }): Promise<{
+      system: SessionSystemMessage[];
+      messages?: ModelMessage[];
+    }> => {
+      const injectedMessages = drainInjectedUserMessages();
+      const turnState = this.getTurnState();
+      const onStepCallback = turnState?.onStepCallback;
+      if (
+        typeof onStepCallback !== "function" &&
+        injectedMessages.length === 0
+      ) {
+        return { system: input.system };
+      }
+
+      const incomingMessages: ModelMessage[] = Array.isArray(messages)
+        ? messages
+        : [];
+      let outMessages: ModelMessage[] | undefined;
+      try {
+        const mergedMessages =
+          typeof onStepCallback === "function"
+            ? await onStepCallback()
+            : [];
+        const mergedWithInjected = [
+          ...injectedMessages,
+          ...(Array.isArray(mergedMessages) ? mergedMessages : []),
+        ];
+        const mergedModelMessages = await input.appendMergedUserMessages(
+          mergedWithInjected,
+        );
+        if (mergedModelMessages.length > 0) {
+          // 关键点（中文）：保持当前 step 顺序，仅把新增 chat user 消息追加到末尾。
+          outMessages = [...incomingMessages, ...mergedModelMessages];
+        }
+      } catch {
+        // ignore merge hook failures
+      }
+      return {
+        system: input.system,
+        ...(Array.isArray(outMessages) ? { messages: outMessages } : {}),
+      };
+    };
+  }
+}

package/src/chat/runtime/ChatSessionDelete.ts

@@ -0,0 +1,95 @@
+/**
+ * ChatSessionDelete：按 sessionId 彻底删除 chat 会话数据。
+ *
+ * 关键点（中文）
+ * - 删除路由映射（`.downcity/channel/meta.json`）
+ * - 删除 chat 审计目录（`.downcity/chat/<sessionId>/`）
+ * - 删除 core session 目录（`.downcity/agents/<agentId>/sessions/<sessionId>/`）
+ * - 清理运行中 agent 与队列，避免残留任务继续执行
+ */
+
+import fs from "fs-extra";
+import path from "node:path";
+import type { AgentContext } from "@downcity/agent/internal/types/runtime/agent/AgentContext.js";
+import { resolveChatQueueStore } from "@/chat/runtime/ChatQueue.js";
+import { removeChatMetaBySessionId } from "@/chat/runtime/ChatMetaStore.js";
+
+function normalizeSessionId(sessionId: string): string {
+  return String(sessionId || "").trim();
+}
+
+/**
+ * 彻底删除一个 chat session。
+ *
+ * 关键点（中文）
+ * - 幂等：目标不存在时返回 success + deleted=false，避免上层重试复杂化。
+ */
+export async function deleteChatSessionById(params: {
+  context: AgentContext;
+  sessionId: string;
+}): Promise<{
+  success: boolean;
+  sessionId: string;
+  deleted: boolean;
+  removedMeta: boolean;
+  removedChatDir: boolean;
+  removedSessionDir: boolean;
+  error?: string;
+}> {
+  const sessionId = normalizeSessionId(params.sessionId);
+  if (!sessionId) {
+    return {
+      success: false,
+      sessionId: "",
+      deleted: false,
+      removedMeta: false,
+      removedChatDir: false,
+      removedSessionDir: false,
+      error: "Missing sessionId",
+    };
+  }
+
+  try {
+    // 关键点（中文）：先停执行，再删文件，避免删除过程中仍有任务写入。
+    params.context.session.get(sessionId).clearExecutor();
+    resolveChatQueueStore(params.context).clear(sessionId);
+
+    const removedMetaResult = await removeChatMetaBySessionId({
+      context: params.context,
+      sessionId,
+    });
+
+    const chatDir = path.join(params.context.rootPath, ".downcity", "chat", sessionId);
+    const sessionDir = params.context.paths.getDowncitySessionDirPath(sessionId);
+    const hadChatDir = await fs.pathExists(chatDir);
+    const hadSessionDir = await fs.pathExists(sessionDir);
+    if (hadChatDir) {
+      await fs.remove(chatDir);
+    }
+    if (hadSessionDir) {
+      await fs.remove(sessionDir);
+    }
+
+    const deleted =
+      removedMetaResult.removed || hadChatDir || hadSessionDir;
+
+    return {
+      success: true,
+      sessionId,
+      deleted,
+      removedMeta: removedMetaResult.removed,
+      removedChatDir: hadChatDir,
+      removedSessionDir: hadSessionDir,
+    };
+  } catch (error) {
+    return {
+      success: false,
+      sessionId,
+      deleted: false,
+      removedMeta: false,
+      removedChatDir: false,
+      removedSessionDir: false,
+      error: String(error),
+    };
+  }
+}

package/src/chat/runtime/ChatSessionTypes.ts

@@ -0,0 +1,32 @@
+/**
+ * ChatSession 相关类型定义。
+ *
+ * 关键点（中文）
+ * - Chat 专用 session 会把“队列消息合并 / step 回发”收敛到 chat 层自身。
+ * - 普通 Session 仍可复用基础 `run / append*` 能力，不强耦合 chat 语义。
+ */
+
+import type { SessionUserMessageV1 } from "@downcity/agent/internal/executor/types/SessionMessages.js";
+import type { SessionAssistantStepCallback } from "@downcity/agent/internal/executor/types/SessionRun.js";
+
+/**
+ * ChatSession 单次 turn 绑定的运行态。
+ */
+export interface ChatSessionTurnState {
+  /**
+   * 提取本轮 step 边界新增的 user 消息。
+   *
+   * 关键点（中文）
+   * - 该回调用于把同一 chat lane 后续到达的消息并入当前推理。
+   * - 若未提供，则表示当前 turn 不启用 step 合并。
+   */
+  onStepCallback?: () => Promise<SessionUserMessageV1[]>;
+
+  /**
+   * assistant step 回发钩子。
+   *
+   * 关键点（中文）
+   * - ChatSession 内部会先完成 step 持久化，再调用该钩子做真实渠道发送。
+   */
+  onAssistantStepCallback?: SessionAssistantStepCallback;
+}

package/src/chat/runtime/ChatkeySend.ts

@@ -0,0 +1,187 @@
+/**
+ * Send text to a target chat using chatKey.
+ *
+ * 设计动机（中文）
+ * - Task runner / scheduler 需要在“非当前对话上下文”向指定 chatKey 投递消息
+ * - 复用现有 dispatcher 与 chat meta（尤其 QQ 的被动回复依赖 messageId）
+ *
+ * 注意
+ * - 这里是运行时内部能力（不是 tool）；tool `chat_contact_send` 也会复用本实现
+ */
+
+import { getChatSender } from "./ChatSendRegistry.js";
+import type {
+  ChatDispatchAction,
+  ChatDispatchChannel,
+} from "@/chat/types/ChatDispatcher.js";
+import type { AgentContext } from "@downcity/agent/internal/types/runtime/agent/AgentContext.js";
+import { readChatMetaBySessionId } from "./ChatMetaStore.js";
+
+/**
+ * 解析实际分发目标。
+ *
+ * 规则（中文）
+ * - 仅使用 chat plugin runtime 维护的 session 路由映射。
+ * - 不再支持 legacy chatKey 字符串解析回退。
+ */
+export async function resolveDispatchTargetByChatKey(params: {
+  context: AgentContext;
+  chatKey: string;
+}): Promise<{
+  channel: ChatDispatchChannel;
+  chatId: string;
+  chatType?: string;
+  messageThreadId?: number;
+  messageId?: string;
+} | null> {
+  const storedMeta = await readChatMetaBySessionId({
+    context: params.context,
+    sessionId: params.chatKey,
+  });
+  const channel = storedMeta?.channel;
+  const chatId = String(storedMeta?.chatId || "").trim();
+  if (!channel || !chatId) return null;
+
+  const chatType =
+    typeof storedMeta?.targetType === "string" && storedMeta.targetType
+      ? storedMeta.targetType
+      : undefined;
+  const messageThreadId =
+    typeof storedMeta?.threadId === "number" &&
+    Number.isFinite(storedMeta.threadId)
+      ? storedMeta.threadId
+      : undefined;
+  const messageId =
+    typeof storedMeta?.messageId === "string" && storedMeta.messageId
+      ? storedMeta.messageId
+      : undefined;
+
+  return {
+    channel: channel as ChatDispatchChannel,
+    chatId,
+    ...(typeof chatType === "string" && chatType ? { chatType } : {}),
+    ...(typeof messageThreadId === "number" ? { messageThreadId } : {}),
+    ...(typeof messageId === "string" && messageId ? { messageId } : {}),
+  };
+}
+
+/**
+ * 按 chatKey 发送文本到对应平台。
+ *
+ * 流程（中文）
+ * 1) 通过 sessionId 读取映射并定位 channel dispatcher
+ * 2) 从 chat meta 回填 chatType/threadId/messageId
+ * 3) 合并参数后调用 dispatcher 发送
+ */
+export async function sendTextByChatKey(params: {
+  context: AgentContext;
+  chatKey: string;
+  text: string;
+  replyToMessage?: boolean;
+  messageId?: string;
+}): Promise<{ success: boolean; error?: string }> {
+  const context = params.context;
+  const chatKey = String(params.chatKey || "").trim();
+  const text = String(params.text ?? "");
+  if (!chatKey) return { success: false, error: "Missing chatKey" };
+  if (!text.trim()) return { success: true };
+
+  const target = await resolveDispatchTargetByChatKey({ context, chatKey });
+  if (!target) {
+    return {
+      success: false,
+      error: `Unsupported sessionId for dispatch: ${chatKey}`,
+    };
+  }
+
+  const channel = target.channel;
+  const chatId = target.chatId;
+
+  const dispatcher = getChatSender(channel);
+  if (!dispatcher) {
+    return {
+      success: false,
+      error: `No dispatcher registered for channel: ${channel}`,
+    };
+  }
+
+  const chatType = target.chatType;
+  const messageThreadId = target.messageThreadId;
+  const explicitMessageId = String(params.messageId || "").trim();
+  const messageId = explicitMessageId || target.messageId;
+  const shouldReplyToMessage = params.replyToMessage === true;
+
+  if (channel === "qq") {
+    if (!chatType || !messageId) {
+      return {
+        success: false,
+        error:
+          "QQ requires chatType + messageId to send a reply. Ask the target user to send a message first so Downcity can record latest chat meta.",
+      };
+    }
+  }
+
+  return dispatcher.sendText({
+    chatId,
+    text,
+    ...(typeof messageThreadId === "number" ? { messageThreadId } : {}),
+    ...(typeof chatType === "string" && chatType ? { chatType } : {}),
+    ...(typeof messageId === "string" && messageId ? { messageId } : {}),
+    ...(shouldReplyToMessage ? { replyToMessage: true } : {}),
+  });
+}
+
+/**
+ * 按 chatKey 发送平台动作（typing/react）。
+ *
+ * 流程（中文）
+ * 1) 通过 sessionId 读取映射并定位 channel dispatcher
+ * 2) 合并目标元信息与显式参数（显式 messageId 优先）
+ * 3) 调用 dispatcher.sendAction
+ */
+export async function sendActionByChatKey(params: {
+  context: AgentContext;
+  chatKey: string;
+  action: ChatDispatchAction;
+  messageId?: string;
+  reactionEmoji?: string;
+  reactionIsBig?: boolean;
+}): Promise<{ success: boolean; error?: string }> {
+  const context = params.context;
+  const chatKey = String(params.chatKey || "").trim();
+  if (!chatKey) return { success: false, error: "Missing chatKey" };
+  if (!params.action) return { success: false, error: "Missing action" };
+
+  const target = await resolveDispatchTargetByChatKey({ context, chatKey });
+  if (!target) {
+    return {
+      success: false,
+      error: `Unsupported sessionId for dispatch: ${chatKey}`,
+    };
+  }
+
+  const dispatcher = getChatSender(target.channel);
+  if (!dispatcher || typeof dispatcher.sendAction !== "function") {
+    return {
+      success: false,
+      error: `No action dispatcher registered for channel: ${target.channel}`,
+    };
+  }
+
+  const messageId = String(params.messageId || "").trim() || target.messageId;
+  return dispatcher.sendAction({
+    chatId: target.chatId,
+    action: params.action,
+    ...(typeof target.messageThreadId === "number"
+      ? { messageThreadId: target.messageThreadId }
+      : {}),
+    ...(typeof target.chatType === "string" && target.chatType
+      ? { chatType: target.chatType }
+      : {}),
+    ...(typeof messageId === "string" && messageId ? { messageId } : {}),
+    ...(typeof params.reactionEmoji === "string" && params.reactionEmoji.trim()
+      ? { reactionEmoji: params.reactionEmoji.trim() }
+      : {}),
+    ...(params.reactionIsBig === true ? { reactionIsBig: true } : {}),
+  });
+}

package/src/chat/runtime/DirectDispatchParser.ts

@@ -0,0 +1,158 @@
+/**
+ * DirectDispatchParser：direct 模式 assistant 文本解析器。
+ *
+ * 关键点（中文）
+ * - 默认把 assistant 文本原样当作用户可见正文发送。
+ * - frontmatter metadata 语义与 `city chat send` 保持一致。
+ * - 额外保留 `react` 字段用于 direct 模式贴表情。
+ */
+
+import type {
+  DirectReactTagPayload,
+  ResolvedDirectDispatchPlan,
+  ResolvedDirectReactionPayload,
+  ResolvedDirectTextPayload,
+} from "@/chat/types/DirectDispatch.js";
+import {
+  buildChatMessageText,
+  parseChatMessageMarkup,
+} from "@downcity/agent/internal/executor/messages/ChatMessageMarkup.js";
+import { parseChatSendOptionsFromMetadata } from "@/chat/runtime/ChatSendMetadata.js";
+import type { ChatMessageSegment } from "@downcity/agent/internal/executor/messages/ChatMessageMarkupTypes.js";
+
+function normalizeText(value: unknown): string {
+  return String(value ?? "").trim();
+}
+
+function parseBoolean(value: unknown): boolean {
+  if (typeof value === "boolean") return value;
+  const text = normalizeText(value).toLowerCase();
+  return text === "true" || text === "1" || text === "yes";
+}
+
+function parseReactionFromMetadata(value: unknown): DirectReactTagPayload | null {
+  if (typeof value === "string") {
+    const emoji = normalizeText(value);
+    return emoji ? { emoji } : null;
+  }
+  if (!value || typeof value !== "object" || Array.isArray(value)) {
+    return null;
+  }
+  const raw = value as Record<string, unknown>;
+  const emoji = normalizeText(raw.emoji);
+  if (!emoji) return null;
+  const big = parseBoolean(raw.big);
+  return {
+    emoji,
+    ...(big ? { big: true } : {}),
+  };
+}
+
+function parseReactionsFromMetadata(
+  metadata: Record<string, unknown>,
+): DirectReactTagPayload[] {
+  const out: DirectReactTagPayload[] = [];
+  const raw = metadata.react;
+  if (!raw) return out;
+  const list = Array.isArray(raw) ? raw : [raw];
+  for (const item of list) {
+    const parsed = parseReactionFromMetadata(item);
+    if (!parsed) continue;
+    out.push(parsed);
+  }
+  return out;
+}
+
+function resolveTextPlan(params: {
+  fallbackChatKey: string;
+  metadata: Record<string, unknown>;
+  segments: ChatMessageSegment[];
+}): ResolvedDirectTextPayload | null {
+  const sendOptions = parseChatSendOptionsFromMetadata({
+    metadata: params.metadata,
+    strict: false,
+  });
+  const chatKey = normalizeText(sendOptions.chatKey || params.fallbackChatKey);
+  const text = buildChatMessageText({
+    segments: params.segments,
+  });
+  if (!chatKey || !text) return null;
+
+  return {
+    text,
+    chatKey,
+    replyToMessage: sendOptions.replyToMessage === true,
+    ...(typeof sendOptions.messageId === "string" && sendOptions.messageId
+      ? { messageId: sendOptions.messageId }
+      : {}),
+    ...(typeof sendOptions.delayMs === "number"
+      ? { delayMs: sendOptions.delayMs }
+      : {}),
+    ...(typeof sendOptions.sendAtMs === "number"
+      ? { sendAtMs: sendOptions.sendAtMs }
+      : {}),
+  };
+}
+
+function resolveReactionPlans(params: {
+  fallbackChatKey: string;
+  metadata: Record<string, unknown>;
+  reacts: DirectReactTagPayload[];
+}): ResolvedDirectReactionPayload[] {
+  const out: ResolvedDirectReactionPayload[] = [];
+  const sendOptions = parseChatSendOptionsFromMetadata({
+    metadata: params.metadata,
+    strict: false,
+  });
+  const chatKey = normalizeText(sendOptions.chatKey || params.fallbackChatKey);
+  const messageId = normalizeText(sendOptions.messageId);
+  if (!chatKey) return out;
+
+  for (const react of params.reacts) {
+    const emoji = normalizeText(react.emoji);
+    if (!emoji) continue;
+    out.push({
+      emoji,
+      chatKey,
+      ...(messageId ? { messageId } : {}),
+      big: react.big === true,
+    });
+  }
+  return out;
+}
+
+/**
+ * 从 assistant 文本中解析 direct 出站执行计划。
+ *
+ * 协议（中文）
+ * - frontmatter metadata：与 `city chat send` 参数保持一致。
+ * - 附件统一使用 `<file type=\"document|photo|voice|audio|video\">path</file>`。
+ * - `react` 仍仅用于 direct 模式的反应动作。
+ */
+export function parseDirectDispatchAssistantText(params: {
+  assistantText: string;
+  fallbackChatKey: string;
+}): ResolvedDirectDispatchPlan | null {
+  const source = String(params.assistantText ?? "");
+  const fallbackChatKey = normalizeText(params.fallbackChatKey);
+  if (!normalizeText(source) || !fallbackChatKey) return null;
+
+  const parsed = parseChatMessageMarkup(source);
+  const reacts = parseReactionsFromMetadata(parsed.metadata);
+  const textPlan = resolveTextPlan({
+    fallbackChatKey,
+    metadata: parsed.metadata,
+    segments: parsed.segments,
+  });
+  const reactionPlans = resolveReactionPlans({
+    fallbackChatKey,
+    metadata: parsed.metadata,
+    reacts,
+  });
+
+  if (!textPlan && reactionPlans.length === 0) return null;
+  return {
+    text: textPlan,
+    reactions: reactionPlans,
+  };
+}

package/src/chat/runtime/EnqueueDispatch.ts

@@ -0,0 +1,49 @@
+/**
+ * Chat enqueue dispatch helper。
+ *
+ * 关键点（中文）
+ * - 统一封装入队前/后的扩展点调用。
+ * - service 通过这里暴露 queue 生命周期，不直接散落调用细节。
+ */
+
+import type { AgentContext } from "@downcity/agent/internal/types/runtime/agent/AgentContext.js";
+import type {
+  ChatEnqueueEffectInput,
+  ChatEnqueuePipelineInput,
+} from "@/chat/types/ChatPlugin.js";
+import type { JsonValue } from "@downcity/agent/internal/types/common/Json.js";
+import { CHAT_PLUGIN_POINTS } from "@/chat/runtime/PluginPoints.js";
+
+function normalizeText(value: string): string {
+  return String(value || "").trim();
+}
+
+/**
+ * 入队前增强。
+ */
+export async function prepareChatEnqueue(params: {
+  context: AgentContext;
+  input: ChatEnqueuePipelineInput;
+}): Promise<ChatEnqueuePipelineInput> {
+  const normalized: ChatEnqueuePipelineInput = {
+    ...params.input,
+    text: normalizeText(params.input.text),
+  };
+  return (params.context.plugins.pipeline<JsonValue>(
+    CHAT_PLUGIN_POINTS.beforeEnqueue,
+    normalized as unknown as JsonValue,
+  ) as unknown) as Promise<ChatEnqueuePipelineInput>;
+}
+
+/**
+ * 入队后通知。
+ */
+export async function emitChatEnqueueEffect(params: {
+  context: AgentContext;
+  input: ChatEnqueueEffectInput;
+}): Promise<void> {
+  await params.context.plugins.effect(
+    CHAT_PLUGIN_POINTS.afterEnqueue,
+    params.input as unknown as JsonValue,
+  );
+}

package/src/chat/runtime/InboundAugment.ts

@@ -0,0 +1,63 @@
+/**
+ * Chat inbound augment helper。
+ *
+ * 关键点（中文）
+ * - chat plugin runtime 先构造基础输入，再交给 plugin pipeline 做增强。
+ * - 最终拼装顺序固定为：attachmentText -> pluginSections -> bodyText。
+ */
+
+import type { AgentContext } from "@downcity/agent/internal/types/runtime/agent/AgentContext.js";
+import type { ChatInboundAugmentInput } from "@/chat/types/ChatPlugin.js";
+import type { JsonValue } from "@downcity/agent/internal/types/common/Json.js";
+import { CHAT_PLUGIN_POINTS } from "@/chat/runtime/PluginPoints.js";
+
+function normalizeText(value: string | undefined): string | undefined {
+  const text = String(value || "").trim();
+  return text || undefined;
+}
+
+/**
+ * 执行 chat 入站增强 pipeline。
+ */
+export async function augmentChatInboundInput(params: {
+  context: AgentContext;
+  input: ChatInboundAugmentInput;
+}): Promise<ChatInboundAugmentInput> {
+  const normalized: ChatInboundAugmentInput = {
+    ...params.input,
+    ...(params.input.chatType ? { chatType: params.input.chatType } : {}),
+    ...(params.input.chatKey ? { chatKey: params.input.chatKey } : {}),
+    ...(params.input.messageId ? { messageId: params.input.messageId } : {}),
+    ...(normalizeText(params.input.attachmentText)
+      ? { attachmentText: normalizeText(params.input.attachmentText) }
+      : {}),
+    ...(normalizeText(params.input.bodyText)
+      ? { bodyText: normalizeText(params.input.bodyText) }
+      : {}),
+    pluginSections: Array.isArray(params.input.pluginSections)
+      ? params.input.pluginSections.map((item) => String(item || "").trim()).filter(Boolean)
+      : [],
+    attachments: Array.isArray(params.input.attachments) ? params.input.attachments : [],
+  };
+
+  return (params.context.plugins.pipeline<JsonValue>(
+    CHAT_PLUGIN_POINTS.augmentInbound,
+    normalized as unknown as JsonValue,
+  ) as unknown) as Promise<ChatInboundAugmentInput>;
+}
+
+/**
+ * 把增强后的 chat 入站输入拼成最终正文。
+ */
+export function buildChatInboundText(input: ChatInboundAugmentInput): string {
+  return [
+    normalizeText(input.attachmentText),
+    ...(Array.isArray(input.pluginSections)
+      ? input.pluginSections.map((item) => normalizeText(item)).filter(Boolean)
+      : []),
+    normalizeText(input.bodyText),
+  ]
+    .filter(Boolean)
+    .join("\n\n")
+    .trim();
+}