@keyou007/agent-bot 0.1.20-alpha.1 → 0.1.21

package/src/codex/CodexVersion.ts

@@ -0,0 +1,18 @@
+import { compareSemanticVersions } from "../utils/semanticVersion.js";
+
+// Verified protocol baseline: paginated Turn summaries and excludeTurns.
+export const MINIMUM_CODEX_VERSION = "0.153.4";
+
+export class CodexVersionError extends Error {}
+
+export function codexVersionIssue(version: string | undefined): string | undefined {
+  if (version && /^\d+\.\d+\.\d+(?:-[\w.-]+)?(?:\+[\w.-]+)?$/u.test(version)
+    && compareSemanticVersions(version, MINIMUM_CODEX_VERSION) >= 0) return undefined;
+  return `Codex ${version ?? "版本未知"} 不受支持，AgentBot 需要 Codex >= ${MINIMUM_CODEX_VERSION}。`
+    + "请运行 codex update（或 npm install -g @openai/codex@latest）升级，然后安全重启 AgentBot。";
+}
+
+export function assertSupportedCodexVersion(version: string | undefined): void {
+  const issue = codexVersionIssue(version);
+  if (issue) throw new CodexVersionError(issue);
+}

package/src/codex/ProviderModels.ts

@@ -0,0 +1,185 @@
+import type { ModelOption, ReasoningEffortOption } from "../runtime/types.js";
+
+const PROVIDER_MODEL_LIST_TIMEOUT_MS = 10_000;
+
+export interface ProviderModelConfig {
+  base_url?: unknown;
+  env_key?: unknown;
+  experimental_bearer_token?: unknown;
+  query_params?: unknown;
+  http_headers?: unknown;
+  env_http_headers?: unknown;
+  default_model?: unknown;
+  model?: unknown;
+}
+
+export async function fetchProviderModels(input: {
+  providerId: string;
+  config: ProviderModelConfig;
+  catalog: ModelOption[];
+  configuredDefaultModel?: string;
+  environmentValue: (name: string) => string | undefined;
+}): Promise<ModelOption[]> {
+  const baseUrl = stringValue(input.config.base_url)?.trim();
+  if (!baseUrl) {
+    throw new Error(`Provider ${input.providerId} 没有配置 base_url，无法读取模型列表。`);
+  }
+
+  const url = providerModelsUrl(baseUrl, input.config.query_params, input.providerId);
+  const headers = providerModelHeaders(input.config, input.environmentValue);
+  let response: Response;
+  try {
+    response = await fetch(url, {
+      method: "GET",
+      headers,
+      signal: AbortSignal.timeout(PROVIDER_MODEL_LIST_TIMEOUT_MS),
+    });
+  } catch {
+    throw new Error(`无法连接 Provider ${input.providerId} 的模型列表，请检查 Provider 服务和网络。`);
+  }
+  if (!response.ok) {
+    throw new Error(`Provider ${input.providerId} 的模型列表请求失败（HTTP ${response.status}）。`);
+  }
+
+  let payload: unknown;
+  try {
+    payload = await response.json();
+  } catch {
+    throw new Error(`Provider ${input.providerId} 返回了无效的模型列表。`);
+  }
+  const models = normalizeProviderModels(payload, input.catalog, {
+    configuredDefaultModel: input.configuredDefaultModel,
+    providerDefaultModel: stringValue(input.config.default_model)?.trim()
+      ?? stringValue(input.config.model)?.trim(),
+  });
+  if (models.length === 0) {
+    throw new Error(`Provider ${input.providerId} 没有返回可用模型。`);
+  }
+  return models;
+}
+
+function providerModelsUrl(baseUrl: string, queryParams: unknown, providerId: string): URL {
+  let url: URL;
+  try {
+    url = new URL(baseUrl);
+  } catch {
+    throw new Error(`Provider ${providerId} 的 base_url 无效，无法读取模型列表。`);
+  }
+  if (url.protocol !== "http:" && url.protocol !== "https:") {
+    throw new Error(`Provider ${providerId} 的 base_url 不支持模型发现。`);
+  }
+  const path = url.pathname.replace(/\/+$/u, "");
+  if (!/\/models$/iu.test(path)) url.pathname = `${path}/models`;
+  if (isRecord(queryParams)) {
+    for (const [key, value] of Object.entries(queryParams)) {
+      if (!key || value === null || value === undefined || typeof value === "object") continue;
+      url.searchParams.set(key, String(value));
+    }
+  }
+  return url;
+}
+
+function providerModelHeaders(
+  config: ProviderModelConfig,
+  environmentValue: (name: string) => string | undefined,
+): Headers {
+  const headers = new Headers({ Accept: "application/json" });
+  appendHeaderValues(headers, config.http_headers, (value) => value);
+  appendHeaderValues(headers, config.env_http_headers, environmentValue);
+  if (!headers.has("authorization")) {
+    const envKey = stringValue(config.env_key)?.trim();
+    const token = (envKey ? environmentValue(envKey) : undefined)
+      ?? stringValue(config.experimental_bearer_token)?.trim();
+    if (token) headers.set("Authorization", `Bearer ${token}`);
+  }
+  return headers;
+}
+
+function appendHeaderValues(
+  headers: Headers,
+  values: unknown,
+  resolve: (value: string) => string | undefined,
+): void {
+  if (!isRecord(values)) return;
+  for (const [name, rawValue] of Object.entries(values)) {
+    const value = stringValue(rawValue)?.trim();
+    const resolved = value ? resolve(value)?.trim() : undefined;
+    if (name.trim() && resolved) headers.set(name, resolved);
+  }
+}
+
+function normalizeProviderModels(
+  payload: unknown,
+  catalog: ModelOption[],
+  defaults: { configuredDefaultModel?: string; providerDefaultModel?: string },
+): ModelOption[] {
+  const root = isRecord(payload) ? payload : undefined;
+  const entries = Array.isArray(root?.data)
+    ? root.data
+    : Array.isArray(root?.models)
+      ? root.models
+      : Array.isArray(payload)
+        ? payload
+        : [];
+  const catalogById = new Map(catalog.map((model) => [model.id, model]));
+  const normalized = new Map<string, ModelOption>();
+  let itemDefaultModel: string | undefined;
+
+  for (const entry of entries) {
+    const record = isRecord(entry) ? entry : undefined;
+    const id = (typeof entry === "string"
+      ? entry
+      : stringValue(record?.id) ?? stringValue(record?.model) ?? stringValue(record?.name))?.trim();
+    if (!id || normalized.has(id)) continue;
+    const catalogModel = catalogById.get(id);
+    const efforts = reasoningEfforts(record) ?? catalogModel?.supportedReasoningEfforts ?? [];
+    const defaultEffort = stringValue(record?.defaultReasoningEffort)?.trim()
+      ?? stringValue(record?.default_reasoning_effort)?.trim()
+      ?? catalogModel?.defaultReasoningEffort;
+    const displayName = stringValue(record?.displayName)?.trim()
+      ?? stringValue(record?.display_name)?.trim()
+      ?? (stringValue(record?.name)?.trim() !== id ? stringValue(record?.name)?.trim() : undefined)
+      ?? catalogModel?.displayName;
+    if (!itemDefaultModel && (record?.isDefault === true || record?.is_default === true || record?.default === true)) {
+      itemDefaultModel = id;
+    }
+    normalized.set(id, {
+      id,
+      ...(displayName ? { displayName } : {}),
+      supportedReasoningEfforts: efforts,
+      ...(defaultEffort ? { defaultReasoningEffort: defaultEffort } : {}),
+    });
+  }
+
+  const rootDefaultModel = stringValue(root?.defaultModel)?.trim()
+    ?? stringValue(root?.default_model)?.trim();
+  const defaultModel = [rootDefaultModel, itemDefaultModel, defaults.providerDefaultModel, defaults.configuredDefaultModel]
+    .find((candidate) => candidate && normalized.has(candidate));
+  if (defaultModel) normalized.set(defaultModel, { ...normalized.get(defaultModel)!, isDefault: true });
+  return [...normalized.values()];
+}
+
+function reasoningEfforts(record: Record<string, unknown> | undefined): ReasoningEffortOption[] | undefined {
+  if (!record) return undefined;
+  const raw = record.supportedReasoningEfforts ?? record.supported_reasoning_efforts;
+  if (!Array.isArray(raw)) return undefined;
+  const efforts = raw.flatMap((entry): ReasoningEffortOption[] => {
+    if (typeof entry === "string" && entry.trim()) return [{ value: entry.trim() }];
+    if (!isRecord(entry)) return [];
+    const value = stringValue(entry.value)?.trim()
+      ?? stringValue(entry.reasoningEffort)?.trim()
+      ?? stringValue(entry.reasoning_effort)?.trim();
+    if (!value) return [];
+    const description = stringValue(entry.description)?.trim();
+    return [{ value, ...(description ? { description } : {}) }];
+  });
+  return efforts.length > 0 ? efforts : undefined;
+}
+
+function isRecord(value: unknown): value is Record<string, unknown> {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+
+function stringValue(value: unknown): string | undefined {
+  return typeof value === "string" ? value : undefined;
+}

package/src/codex/ProviderSwitch.ts

@@ -0,0 +1,36 @@
+import { AppServerRequestError } from "./AppServerConnection.js";
+import type { RuntimeExecutionSettings } from "../runtime/types.js";
+
+export const PROVIDER_SWITCH_BUSY = "当前任务正在执行，暂时不能切换 Provider。请等待任务完成，或停止任务后重试。";
+
+export function isMissingRolloutError(error: unknown): boolean {
+  if (error instanceof AppServerRequestError && error.method !== "thread/resume") return false;
+  const message = error instanceof AppServerRequestError ? error.serverMessage
+    : error instanceof Error ? error.message : String(error);
+  if (/paginated history lineage|missing source rollout/iu.test(message)) return false;
+  return /no rollout found|rollout[^\n]*(?:not found|missing)/iu.test(message);
+}
+
+export function assertProviderSettingsApplied(
+  actual: { modelProvider?: string; model?: string },
+  requested: Pick<RuntimeExecutionSettings, "modelProvider" | "model">,
+): void {
+  if (actual.modelProvider !== requested.modelProvider) {
+    throw new Error(`Provider 未生效：请求 ${requested.modelProvider}，实际返回 ${actual.modelProvider ?? "未知"}。`);
+  }
+  if (actual.model !== requested.model) {
+    throw new Error(`模型未生效：请求 ${requested.model}，实际返回 ${actual.model ?? "未知"}。请确认目标 Provider 支持该模型。`);
+  }
+}
+
+export function providerSwitchFailure(error: unknown): string {
+  const message = error instanceof Error ? error.message : String(error);
+  if (/active writer/iu.test(message)) return "任务被另一个 App Server 占用。请在原客户端释放任务后重试。";
+  if (/model[^\n]*(?:unsupported|not supported|not found|unavailable|does not exist)|unknown model/iu.test(message)) {
+    return `目标 Provider 不支持当前模型，请选择兼容的模型后重试。${message}`;
+  }
+  if (/unauthorized|forbidden|auth(?:entication|orization)|api.?key|provider[^\n]*(?:not found|unknown|not configured)/iu.test(message)) {
+    return `请检查目标 Provider 的配置和认证信息。${message}`;
+  }
+  return message;
+}

package/src/commands/CommandRouter.ts

@@ -128,8 +128,13 @@ export class CommandRouter {
         throw new Error("/mute 只接受 on 或 off；不传参数等同于 /mute on。");
       }
       case "turns":
-        if (args.length > 0) throw new Error("/turns 不接受参数，请在历史轮次卡片中选择 turn。");
-        return { type: "turns" };
+        rejectOptions("/turn", args);
+        if (args.length > 1) throw new Error("/turn 只接受一个可选的 Turn ID 或序号。");
+        if (args[0] && /^[+-]?(?:\d+(?:\.\d*)?|\.\d+)$/.test(args[0])
+          && (!/^\d+$/.test(args[0]) || !Number.isSafeInteger(Number(args[0])) || Number(args[0]) < 1)) {
+          throw new Error("Turn 序号必须是从 1 开始的正整数。");
+        }
+        return args[0] ? { type: "turns", turnReference: args[0] } : { type: "turns" };
       case "model":
         return settingsCommand("/model", args, { type: "model" });
       case "provider":

package/src/commands/commandTypes.ts

@@ -21,7 +21,7 @@ export type Command =
   | { type: "restart"; force?: boolean }
   | { type: "release" }
   | { type: "mute"; enabled: boolean }
-  | { type: "turns" }
+  | { type: "turns"; turnReference?: string }
   | { type: "model" }
   | { type: "provider" }
   | { type: "thinking" }

package/src/console/ConsoleTurnPresenter.ts

@@ -15,11 +15,14 @@ export class ConsoleTurnPresenter implements TurnPresenter {
     _taskTitle?: string,
     _projectCwd?: string,
     agentLabel?: string,
+    _model?: string,
   ): void {
     this.contexts.set(sessionId, contextKey);
     if (agentLabel) this.agentLabels.set(sessionId, agentLabel);
   }
 
+  updateSessionModel(): void {}
+
   updateSessionTitle(): void {}
 
   unregisterSession(sessionId: string): void {

package/src/feishu/CardRenderer.ts

@@ -123,6 +123,14 @@ export interface PermissionSelectorCardView {
 
 export type ExecutionSettingsTab = "agent" | "provider" | "model" | "thinking" | "permission";
 
+const EXECUTION_SETTING_EFFECTS: Record<ExecutionSettingsTab, string> = {
+  agent: "只影响新建任务，不切换当前任务。",
+  provider: "只影响当前任务，需空闲时切换。",
+  model: "只影响当前任务，下一轮生效。",
+  thinking: "只影响当前任务，下一轮生效。",
+  permission: "只影响当前任务，下一轮生效。",
+};
+
 export interface ExecutionSettingsAgentOption {
   name: string;
   title: string;
@@ -158,6 +166,7 @@ export interface TaskListCardAction {
   text: string;
   type?: "default" | "primary" | "danger";
   value: Record<string, string>;
+  url?: string;
 }
 
 export interface HelpCardCommand {
@@ -542,7 +551,7 @@ export class CardRenderer {
 
     if (view.activeTab === "agent") {
       elements.push(...view.agents.map((agent) => settingsOptionRow({
-        label: `${inlineCode(agent.name)} · ${escapeCardHtml(agent.title)}`,
+        label: inlineCode(agent.name),
         current: agent.name === view.currentAgent,
         action: {
           text: "Switch",
@@ -562,9 +571,6 @@ export class CardRenderer {
         elements.push(...view.providers.map((provider) => settingsOptionRow({
           label: [
             inlineCode(provider.id),
-            provider.displayName && provider.displayName !== provider.id
-              ? ` · ${escapeCardHtml(provider.displayName)}`
-              : "",
             provider.isDefault ? " · 默认" : "",
           ].join(""),
           current: provider.id === view.currentProvider,
@@ -631,6 +637,7 @@ export class CardRenderer {
       })));
     }
 
+    elements.push(markdown(`> ${EXECUTION_SETTING_EFFECTS[view.activeTab]}`));
     return sectionCard("运行设置", elements, view.notice ? "green" : "blue");
   }
 
@@ -1138,7 +1145,7 @@ export class CardRenderer {
     };
   }
 
-  renderTurn(state: TurnViewState): Record<string, unknown> {
+  renderTurn(state: TurnViewState, previewUrl?: string): Record<string, unknown> {
     const elements = this.thinkingCardLayout === "timeline"
       ? renderTurnElements(state, "hidden")
       : renderGroupedTurnElements(state, "hidden");
@@ -1149,23 +1156,31 @@ export class CardRenderer {
         type: "danger",
         value: { action: "turn_cancel", sessionId: state.sessionId, turnId: state.turnId },
       });
+      if (previewUrl) footerActions.push(turnPreviewAction(previewUrl));
       elements.push(
         { tag: "hr" },
-        taskActionRow(footerActions, renderTurnDuration(state)),
+        taskActionRow(footerActions, renderTurnDuration(state), true),
       );
     } else if (state.status === "completed") {
       footerActions.push({
         text: "Reset",
         value: { action: "turn_reset", sessionId: state.sessionId, turnId: state.turnId },
       });
+      if (previewUrl) footerActions.push(turnPreviewAction(previewUrl));
       elements.push(
         { tag: "hr" },
-        taskActionRow(footerActions),
+        taskActionRow(footerActions, undefined, true),
       );
     } else if (state.status === "starting") {
+      if (previewUrl) footerActions.push(turnPreviewAction(previewUrl));
+      elements.push(
+        { tag: "hr" },
+        taskActionRow(footerActions, renderTurnDuration(state), true),
+      );
+    } else if (previewUrl) {
       elements.push(
         { tag: "hr" },
-        taskActionRow([], renderTurnDuration(state)),
+        taskActionRow([turnPreviewAction(previewUrl)], renderTurnDuration(state)),
       );
     }
     if (state.status === "completed") {
@@ -1184,11 +1199,15 @@ export class CardRenderer {
     );
   }
 
-  renderTurnDetails(state: TurnViewState): Record<string, unknown> {
+  renderTurnDetails(state: TurnViewState, previewUrl?: string): Record<string, unknown> {
     const title = state.taskTitle
       ? `任务执行详情：${truncateText(state.taskTitle.replace(/\s+/g, " ").trim(), 60)}`
       : "任务执行详情";
-    return turnCard(title, "blue", renderTurnElements(state, "always"), renderTurnSubtitle(state));
+    const elements = [markdown(`Turn: \`${state.turnId}\``)];
+    if (state.prompt) elements.push(markdown(`**Prompt**\n${truncateText(state.prompt, 1_000)}`));
+    elements.push(...renderTurnElements(state, "always"));
+    if (previewUrl) elements.push(taskActionRow([turnPreviewAction(previewUrl)]));
+    return turnCard(title, "blue", elements, renderTurnSubtitle(state));
   }
 
   renderActivityHistory(state: TurnViewState, requestedPage: number): Record<string, unknown> {
@@ -1531,18 +1550,9 @@ export class CardRenderer {
     if (view.entries.length === 0) {
       elements.push(markdown("当前任务还没有成功完成的 turn。"));
     } else {
+      const sequenceWidth = `${Math.max(16, ...view.entries.map((entry) => String(entry.sequence).length * 10))}px`;
       view.entries.forEach((entry) => {
-        const action = entry.actions?.[0];
-        elements.push(resetHistoryEntryRow(
-          entry.graphNodeLine,
-          entry.graphConnectorLine,
-          entry.lines,
-          entry.timestamp,
-          action,
-          entry.current === true,
-          entry.running === true,
-          entry.resetting === true,
-        ));
+        elements.push(resetHistoryEntryRow(entry, sequenceWidth));
       });
     }
     if (view.footerLines.length > 0) {
@@ -2283,7 +2293,7 @@ function renderToolDetails(tool: ToolState, projectCwd?: string): string {
   return codeBlock([`$ ${commandText}`, resultText].filter((part): part is string => part !== undefined).join("\n"), 2_003);
 }
 
-function formatShellCommandForDisplay(command: string): string {
+export function formatShellCommandForDisplay(command: string): string {
   const normalized = command.replace(/\r\n/g, "\n");
   let result = "";
   let quote: "'" | "\"" | undefined;
@@ -2388,7 +2398,7 @@ function toolPanelTitle(tool: ToolState): string {
   const command = stripAnsi(tool.command ?? tool.title).trim();
   const meaningfulCommand = tool.kind === "web_search"
     ? tool.title
-    : unwrapShellCommand(command) ?? tool.title;
+    : displayToolCommand(command) ?? tool.title;
   const duration = toolDuration(tool);
   const prefix = `${icon} `;
   const suffix = duration ? ` · ${duration}` : "";
@@ -2460,6 +2470,11 @@ function shellCommandStatus(view: ShellCommandCardView): {
   return { title: "命令执行失败", label: `退出码 ${view.exitCode ?? "未知"}`, template: "red" };
 }
 
+export function displayToolCommand(command: string): string | undefined {
+  const clean = stripAnsi(command).trim();
+  return unwrapShellCommand(clean);
+}
+
 function unwrapShellCommand(command: string): string | undefined {
   return unwrapPowerShellCommand(command) ?? unwrapPosixShellCommand(command);
 }
@@ -2825,24 +2840,31 @@ function settingsOptionRow(input: {
 }
 
 function resetHistoryEntryRow(
-  graphNodeLine: string,
-  graphConnectorLine: string | undefined,
-  lines: string[],
-  timestamp: string | undefined,
-  action: TaskListCardAction | undefined,
-  current: boolean,
-  running: boolean,
-  resetting: boolean,
+  entry: ResetHistoryCardEntry,
+  sequenceWidth: string,
 ): Record<string, unknown> {
+  const { graphNodeLine, graphConnectorLine, lines, timestamp, current, running, resetting } = entry;
+  const action = entry.actions?.[0];
   const branchConnectorLine = graphConnectorLine && /[╱╲]/u.test(graphConnectorLine)
     ? graphConnectorLine
     : undefined;
-  const graph = [
-    `<font color='${current ? "green" : running || resetting ? "orange" : "blue"}'>${escapeCardHtml(graphNodeLine)}</font>`,
-    ...(branchConnectorLine
-      ? [`<font color='grey'>${escapeCardHtml(branchConnectorLine)}</font>`]
-      : []),
-  ].join("\n");
+  const color = current ? "green" : running || resetting ? "orange" : "blue";
+  const nodeLanes = graphNodeLine.match(/[●│]/gu) ?? [];
+  const connectorLanes = branchConnectorLine?.split(" ");
+  // Each lane has its own center; shorter connectors and wider turn numbers cannot shift it.
+  const graphColumns = nodeLanes.map((node, lane) => ({
+    tag: "column",
+    width: "16px",
+    vertical_align: "top",
+    padding: "0px",
+    elements: [{
+      ...markdown([
+        `<font color='${color}'>${node}</font>`,
+        ...(connectorLanes?.[lane] ? [`<font color='grey'>${escapeCardHtml(connectorLanes[lane])}</font>`] : []),
+      ].join("\n")),
+      text_align: "center",
+    }],
+  }));
   const trailingElements = current
     ? [markdown("✅ 当前")]
     : resetting
@@ -2863,8 +2885,20 @@ function resetHistoryEntryRow(
         width: "auto",
         vertical_align: "top",
         elements: [{
-          ...markdown(graph),
-          text_align: "center",
+          tag: "column_set",
+          flex_mode: "none",
+          horizontal_spacing: "0px",
+          horizontal_align: "left",
+          columns: [
+            ...graphColumns,
+            {
+              tag: "column",
+              width: sequenceWidth,
+              vertical_align: "top",
+              padding: "0px",
+              elements: [{ ...markdown(`<font color='${color}'>${entry.sequence}</font>`), text_align: "left" }],
+            },
+          ],
         }],
       },
       {
@@ -2997,10 +3031,17 @@ function taskActionElement(action: TaskListCardAction): Record<string, unknown>
     elements: [markdown(
       `<font color='${action.type === "danger" ? "red" : "blue"}'>${escapeCardActionText(action.text)}</font>`,
     )],
-    behaviors: [{
-      type: "callback",
-      value: action.value,
-    }],
+    behaviors: action.url
+      ? [{ type: "open_url", default_url: action.url }]
+      : [{ type: "callback", value: action.value }],
+  };
+}
+
+function turnPreviewAction(previewUrl: string): TaskListCardAction {
+  return {
+    text: "Preview",
+    value: {},
+    url: previewUrl,
   };
 }
 

package/src/feishu/FeishuConnector.ts

@@ -3,7 +3,7 @@ import type { WSClient as LarkWsClient, WSConnectionStatus } from "@larksuiteoap
 import type { AppConfig } from "../config/schema.js";
 import { threadContextKey } from "./contextKey.js";
 import { resolveFeishuBotOpenId } from "./FeishuBotIdentity.js";
-import { normalizeFeishuPostText } from "./InboundText.js";
+import { normalizeFeishuPostText, renderFeishuCodeBlock } from "./InboundText.js";
 import { allowsFeishuUser } from "./ownerAccess.js";
 import type { CardAction, ChatUpdatedEvent, FeishuEventHandler, IncomingMessage } from "./types.js";
 
@@ -327,19 +327,29 @@ function parseMessageContent(
   const title = typeof locale.title === "string" ? normalizeFeishuPostText(locale.title) : "";
   if (title) paragraphs.push(title);
   const images: string[] = [];
-  if (Array.isArray(locale.content)) {
-    for (const row of locale.content) {
+  const rows = Array.isArray(locale.content) ? locale.content : locale.content_v2;
+  if (Array.isArray(rows)) {
+    for (const row of rows) {
       if (!Array.isArray(row)) continue;
       let rowText = "";
+      let preserveFormatting = false;
       for (const element of row) {
         if (!isRecord(element)) continue;
         if ((element.tag === "text" || element.tag === "a") && typeof element.text === "string") {
           rowText += element.text;
+        } else if (element.tag === "md" && typeof element.text === "string") {
+          rowText += element.text;
+          preserveFormatting = true;
+        } else if (element.tag === "code_block" && typeof element.text === "string") {
+          rowText += renderFeishuCodeBlock(element.text, element.language);
+          preserveFormatting = true;
         } else if (element.tag === "img" && typeof element.image_key === "string") {
           images.push(element.image_key);
         }
       }
-      const normalizedRow = normalizeFeishuPostText(rowText);
+      const normalizedRow = preserveFormatting
+        ? rowText.replace(/\r\n?/gu, "\n").trim()
+        : normalizeFeishuPostText(rowText);
       if (normalizedRow) paragraphs.push(normalizedRow);
     }
   }
@@ -347,7 +357,7 @@ function parseMessageContent(
 }
 
 function selectPostLocale(content: Record<string, unknown>): Record<string, unknown> | undefined {
-  if (Array.isArray(content.content)) return content;
+  if (Array.isArray(content.content) || Array.isArray(content.content_v2)) return content;
   for (const locale of ["zh_cn", "en_us", "ja_jp"]) {
     if (isRecord(content[locale])) return content[locale];
   }