@core-workspace/infoflow-openclaw-plugin 2026.3.9 → 2026.3.27-beta.0

package/src/channel/streaming.ts

@@ -0,0 +1,740 @@
+import { randomUUID } from "node:crypto";
+import type { OpenClawConfig } from "openclaw/plugin-sdk/plugin-entry";
+import { formatInfoflowError, getInfoflowSendLog, logVerbose } from "../logging.js";
+import type { InfoflowMessageFormat, ResolvedInfoflowAccount } from "../types.js";
+import { resolveInfoflowAccount } from "./accounts.js";
+import {
+  DEFAULT_TIMEOUT_MS,
+  ensureHttps,
+  extractIdFromRawJson,
+  getAppAccessToken,
+  sendInfoflowMessage,
+} from "./outbound.js";
+
+export const INFOFLOW_STREAMING_CREATE_PATH = "/api/v1/msg/sender/interactivity_msg";
+export const INFOFLOW_STREAMING_UPDATE_PERSONAL_PATH =
+  "/api/v1/msg/modifier/interactivity_personal_msg_content";
+export const INFOFLOW_STREAMING_UPDATE_GROUP_PATH = "/api/v1/msg/modifier/dynamic_content";
+
+const STREAMING_TEMPLATE_NAME = "streaming_render";
+const STREAMING_TEMPLATE_VERSION = 30;
+const STREAMING_GROUP_VERSION = 111;
+const STREAMING_INTERACTIVITY_EXPIRE_SECONDS = 7_776_000;
+const STREAMING_FLUSH_INTERVAL_MS = 600;
+const MAX_CARD_TEXT_LENGTH = 6_000;
+const MAX_THINKING_TEXT_LENGTH = 10_000;
+const MAX_TOOL_ENTRIES = 12;
+const MAX_PHASE_ENTRIES = 8;
+const DEFAULT_OFFLINE_NOTIFY_TEXT = "你收到一条卡片消息";
+const DEFAULT_PENDING_STATUS = "收到啦，正在处理中～";
+const DEFAULT_THINKING_STATUS = "思考中";
+const DEFAULT_DONE_STATUS = "思考完成";
+const DEFAULT_FAILED_STATUS = "生成失败";
+
+type StreamingTextNode = {
+  type: "text";
+  content: string;
+};
+
+export type InfoflowStreamingCardContent = Record<string, StreamingTextNode | undefined>;
+
+export type CreateStreamingCardResult = {
+  ok: boolean;
+  messageid?: string;
+  msgseqid?: string;
+  modifyToken?: string;
+  error?: string;
+};
+
+export type UpdateStreamingCardResult = {
+  ok: boolean;
+  error?: string;
+};
+
+type ToolTrace = {
+  id: number;
+  name: string;
+  status: "running" | "done";
+  details: string[];
+};
+
+type StreamingTarget =
+  | {
+      kind: "direct";
+      receiverId: string;
+      receiverType: "user";
+      to: string;
+      userIds: string[];
+    }
+  | {
+      kind: "group";
+      receiverId: string;
+      receiverType: "group";
+      to: string;
+      groupId: number;
+    };
+
+function toTextNode(content: string | undefined): StreamingTextNode | undefined {
+  const normalized = content?.trimEnd();
+  if (!normalized) {
+    return undefined;
+  }
+  return { type: "text", content: normalized };
+}
+
+function truncateTail(text: string, maxLength: number): string {
+  if (text.length <= maxLength) {
+    return text;
+  }
+  return `...\n${text.slice(text.length - maxLength + 4)}`;
+}
+
+function mergeStreamingSnapshot(current: string, incoming: string): string {
+  const next = incoming.trimEnd();
+  if (!next) {
+    return current;
+  }
+  if (!current) {
+    return next;
+  }
+  if (next === current) {
+    return current;
+  }
+  // Most OpenClaw partials are "latest snapshots", not pure deltas.
+  if (next.startsWith(current)) {
+    return next;
+  }
+  if (current.startsWith(next)) {
+    return current;
+  }
+  // If the new chunk clearly continues the tail, append only the non-overlap.
+  const maxOverlap = Math.min(current.length, next.length);
+  for (let overlap = maxOverlap; overlap >= 16; overlap -= 1) {
+    if (current.slice(-overlap) === next.slice(0, overlap)) {
+      return current + next.slice(overlap);
+    }
+  }
+  // Otherwise prefer the latest snapshot to avoid duplicated paragraphs.
+  return next;
+}
+
+function normalizeStreamingTarget(to: string): StreamingTarget | undefined {
+  const normalized = to.replace(/^infoflow:/i, "");
+  const groupMatch = normalized.match(/^group:(\d+)$/i);
+  if (groupMatch) {
+    return {
+      kind: "group",
+      receiverId: groupMatch[1],
+      receiverType: "group",
+      to: normalized,
+      groupId: Number(groupMatch[1]),
+    };
+  }
+  const userId = normalized.trim();
+  if (!userId) {
+    return undefined;
+  }
+  return {
+    kind: "direct",
+    receiverId: userId,
+    receiverType: "user",
+    to: userId,
+    userIds: [userId],
+  };
+}
+
+function buildToolTraceMarkdown(entries: ToolTrace[]): string {
+  if (entries.length === 0) {
+    return "";
+  }
+  return entries
+    .map((entry) => {
+      const summary = `${entry.id}. ${entry.name} · ${entry.status === "done" ? "已完成" : "执行中"}`;
+      const details = entry.details.length > 0 ? entry.details.join("\n\n") : "- 暂无详情";
+      return [`<details>`, `<summary>${summary}</summary>`, ``, details, ``, `</details>`].join(
+        "\n",
+      );
+    })
+    .join("\n\n");
+}
+
+function buildThinkingSection(params: {
+  phaseHistory: string[];
+  reasoningText: string;
+  toolEntries: ToolTrace[];
+}): string {
+  const sections: string[] = [];
+  if (params.phaseHistory.length > 0) {
+    sections.push(`## 处理状态\n${params.phaseHistory.map((item) => `- ${item}`).join("\n")}`);
+  }
+  const reasoning = params.reasoningText.trim();
+  if (reasoning) {
+    sections.push(`## Agent 过程\n${reasoning}`);
+  }
+  if (params.toolEntries.length > 0) {
+    sections.push(`## 工具调用详情\n${buildToolTraceMarkdown(params.toolEntries)}`);
+  }
+  return truncateTail(sections.join("\n\n"), MAX_THINKING_TEXT_LENGTH);
+}
+
+function buildCardContent(params: {
+  answerText: string;
+  answerFormat: "text" | "markdown";
+  phaseHistory: string[];
+  reasoningText: string;
+  toolEntries: ToolTrace[];
+  statusInfo: string;
+  phaseLabel: string;
+  done: boolean;
+  failed: boolean;
+}): InfoflowStreamingCardContent {
+  const thinkingSection = buildThinkingSection({
+    phaseHistory: params.phaseHistory,
+    reasoningText: params.reasoningText,
+    toolEntries: params.toolEntries,
+  });
+  const answerKey = params.answerFormat === "markdown" ? "ai_markdown" : "ai_text";
+  const answerText = truncateTail(params.answerText.trim(), MAX_CARD_TEXT_LENGTH);
+  const hasThinkingSection = thinkingSection.trim().length > 0;
+  const summaryText = truncateTail(params.statusInfo, 160);
+  return {
+    card_init: toTextNode("1"),
+    answer_summary: toTextNode(summaryText),
+    [answerKey]: toTextNode(answerText),
+    status_info: toTextNode(params.statusInfo),
+    thinking_aio: hasThinkingSection ? toTextNode(thinkingSection) : undefined,
+    think_star_img: toTextNode("ast/think_star_static.png"),
+    think_status_img: toTextNode("ast/thinking_yes.png"),
+    think_status_color: toTextNode(params.failed ? "#D03050" : "#5C6473"),
+    think_status_text: toTextNode(params.phaseLabel),
+    think_arrow_img: hasThinkingSection ? toTextNode("ast/arrow_down.png") : undefined,
+    think_layout_install: toTextNode(hasThinkingSection ? "1" : "0"),
+    status_info_1_install: toTextNode("0"),
+    flex_item_status_info_1_install: toTextNode("0"),
+    dc_print_end: params.done ? toTextNode("1") : undefined,
+  };
+}
+
+async function fetchStreamingJson(params: {
+  account: ResolvedInfoflowAccount;
+  path: string;
+  payload: Record<string, unknown>;
+  timeoutMs?: number;
+}): Promise<{ ok: boolean; raw?: string; data?: Record<string, unknown>; error?: string }> {
+  const { account, path, payload, timeoutMs = DEFAULT_TIMEOUT_MS } = params;
+  const { apiHost, appKey, appSecret } = account.config;
+
+  if (!appKey || !appSecret) {
+    return { ok: false, error: "Infoflow appKey/appSecret not configured." };
+  }
+
+  const tokenResult = await getAppAccessToken({ apiHost, appKey, appSecret, timeoutMs });
+  if (!tokenResult.ok || !tokenResult.token) {
+    return { ok: false, error: tokenResult.error ?? "failed to get token" };
+  }
+
+  let timeout: ReturnType<typeof setTimeout> | undefined;
+  try {
+    const controller = new AbortController();
+    timeout = setTimeout(() => controller.abort(), timeoutMs);
+    const bodyStr = JSON.stringify(payload);
+    const headers = {
+      Authorization: `Bearer-${tokenResult.token}`,
+      "Content-Type": "application/json; charset=utf-8",
+      LOGID: randomUUID(),
+    };
+    const res = await fetch(`${ensureHttps(apiHost)}${path}`, {
+      method: "POST",
+      headers,
+      body: bodyStr,
+      signal: controller.signal,
+    });
+    const raw = await res.text();
+    const data = JSON.parse(raw) as Record<string, unknown>;
+    const outerCode = typeof data.code === "string" ? data.code : "";
+    if (outerCode && outerCode !== "ok") {
+      return {
+        ok: false,
+        raw,
+        data,
+        error: String(data.message ?? data.errmsg ?? `code=${outerCode}`),
+      };
+    }
+    const nested = data.data as Record<string, unknown> | undefined;
+    const nestedErrCode = nested?.errcode;
+    if (nestedErrCode != null && nestedErrCode !== 0) {
+      return {
+        ok: false,
+        raw,
+        data,
+        error: String(nested?.errmsg ?? `errcode ${nestedErrCode}`),
+      };
+    }
+    return { ok: true, raw, data };
+  } catch (err) {
+    return { ok: false, error: formatInfoflowError(err) };
+  } finally {
+    clearTimeout(timeout);
+  }
+}
+
+export async function createStreamingCard(params: {
+  account: ResolvedInfoflowAccount;
+  to: string;
+  content: InfoflowStreamingCardContent;
+  timeoutMs?: number;
+}): Promise<CreateStreamingCardResult> {
+  const target = normalizeStreamingTarget(params.to);
+  if (!target) {
+    return { ok: false, error: `invalid streaming target: ${params.to}` };
+  }
+
+  const timestamp = Date.now();
+  const payload = {
+    contents: params.content,
+    meta: {
+      client_msg_id: timestamp,
+      client_send_time: timestamp,
+      interactivity_expire: STREAMING_INTERACTIVITY_EXPIRE_SECONDS,
+      interactivity_mode: "normal",
+      modify_expire: STREAMING_INTERACTIVITY_EXPIRE_SECONDS,
+      offline_notify_txt: DEFAULT_OFFLINE_NOTIFY_TEXT,
+      template: {
+        name: STREAMING_TEMPLATE_NAME,
+        version: STREAMING_TEMPLATE_VERSION,
+      },
+    },
+    type: 1,
+    content_id: String(timestamp),
+    receiver_id: target.receiverId,
+    receiver_type: target.receiverType,
+    scene: "IM-server",
+    user_msg: false,
+  };
+
+  getInfoflowSendLog().info(
+    `[streaming:create] to=${target.to}, receiverType=${target.receiverType}, template=${STREAMING_TEMPLATE_NAME}`,
+  );
+  logVerbose(`[streaming:create] POST body: ${JSON.stringify(payload)}`);
+
+  const result = await fetchStreamingJson({
+    account: params.account,
+    path: INFOFLOW_STREAMING_CREATE_PATH,
+    payload,
+    timeoutMs: params.timeoutMs,
+  });
+  if (!result.ok || !result.raw || !result.data) {
+    getInfoflowSendLog().error(`[streaming:create] failed: ${result.error}`);
+    return { ok: false, error: result.error ?? "create streaming card failed" };
+  }
+
+  const nested = (result.data.data as Record<string, unknown> | undefined) ?? result.data;
+  const receiver =
+    Array.isArray(nested.receivers) && nested.receivers.length > 0
+      ? (nested.receivers[0] as Record<string, unknown>)
+      : undefined;
+  const messageid =
+    extractIdFromRawJson(result.raw, "messageid") ??
+    extractIdFromRawJson(result.raw, "msgid") ??
+    extractIdFromRawJson(result.raw, "msg_id") ??
+    (nested.messageid != null ? String(nested.messageid) : undefined) ??
+    (receiver?.msg_id != null ? String(receiver.msg_id) : undefined);
+  const msgseqid =
+    extractIdFromRawJson(result.raw, "msgseqid") ??
+    extractIdFromRawJson(result.raw, "msg_seq") ??
+    (nested.msgseqid != null ? String(nested.msgseqid) : undefined) ??
+    (receiver?.msg_seq != null ? String(receiver.msg_seq) : undefined);
+  const modifyToken =
+    extractIdFromRawJson(result.raw, "modify_token") ??
+    extractIdFromRawJson(result.raw, "interactivity_token") ??
+    (nested.modify_token != null ? String(nested.modify_token) : undefined) ??
+    (receiver?.modify_token != null ? String(receiver.modify_token) : undefined);
+
+  if (!modifyToken) {
+    getInfoflowSendLog().error(`[streaming:create] missing modify_token in response`);
+    return { ok: false, error: "create streaming card succeeded but modify_token is missing" };
+  }
+
+  getInfoflowSendLog().info(
+    `[streaming:create] ok: to=${target.to}, messageid=${messageid ?? "?"}`,
+  );
+  return { ok: true, messageid, msgseqid, modifyToken };
+}
+
+export async function updateStreamingCard(params: {
+  account: ResolvedInfoflowAccount;
+  to: string;
+  modifyToken: string;
+  content: InfoflowStreamingCardContent;
+  groupVersion?: number;
+  timeoutMs?: number;
+}): Promise<UpdateStreamingCardResult> {
+  const target = normalizeStreamingTarget(params.to);
+  if (!target) {
+    return { ok: false, error: `invalid streaming target: ${params.to}` };
+  }
+
+  const payload =
+    target.kind === "group"
+      ? {
+          modify_token: params.modifyToken,
+          new_dynamic_msg_content: params.content,
+          version: params.groupVersion ?? STREAMING_GROUP_VERSION,
+          notify_list: [
+            {
+              to_type: 2,
+              to_ids: [target.groupId],
+            },
+          ],
+        }
+      : {
+          modify_token: params.modifyToken,
+          new_personal_msg_content: [
+            {
+              user_ids: target.userIds,
+              personal_msg_content: params.content,
+              notify_msg_content: null,
+            },
+          ],
+        };
+
+  const path =
+    target.kind === "group"
+      ? INFOFLOW_STREAMING_UPDATE_GROUP_PATH
+      : INFOFLOW_STREAMING_UPDATE_PERSONAL_PATH;
+
+  getInfoflowSendLog().info(
+    `[streaming:update] to=${target.to}, path=${path}, hasThinking=${Boolean(params.content.thinking_aio)}`,
+  );
+  logVerbose(`[streaming:update] POST body: ${JSON.stringify(payload)}`);
+
+  const result = await fetchStreamingJson({
+    account: params.account,
+    path,
+    payload,
+    timeoutMs: params.timeoutMs,
+  });
+  if (!result.ok) {
+    getInfoflowSendLog().error(`[streaming:update] failed: ${result.error}`);
+    return { ok: false, error: result.error ?? "update streaming card failed" };
+  }
+  getInfoflowSendLog().info(
+    `[streaming:update] ok: to=${target.to}${target.kind === "group" ? `, version=${params.groupVersion ?? STREAMING_GROUP_VERSION}` : ""}`,
+  );
+  return { ok: true };
+}
+
+export class InfoflowStreamingCardSession {
+  private readonly account: ResolvedInfoflowAccount;
+  private readonly cfg: OpenClawConfig;
+  private readonly to: string;
+  private readonly accountId?: string;
+  private readonly answerFormat: "text" | "markdown";
+  private readonly fallbackFormat: "text" | "markdown";
+  private readonly toolEntries: ToolTrace[] = [];
+  private readonly phaseHistory: string[] = [DEFAULT_PENDING_STATUS];
+  private assistantText = "";
+  private reasoningText = "";
+  private statusInfo = DEFAULT_PENDING_STATUS;
+  private phaseLabel = DEFAULT_PENDING_STATUS;
+  private sawAssistantStream = false;
+  private started = false;
+  private failed = false;
+  private completed = false;
+  private createError: string | undefined;
+  private modifyToken: string | undefined;
+  private groupUpdateVersion = STREAMING_GROUP_VERSION;
+  private nextToolTraceId = 1;
+  private activeToolTraceId: number | undefined;
+  private flushTimer: ReturnType<typeof setTimeout> | undefined;
+  private flushPromise: Promise<void> | undefined;
+  private flushQueued = false;
+
+  constructor(params: {
+    cfg: OpenClawConfig;
+    accountId?: string;
+    to: string;
+    answerFormat?: "text" | "markdown";
+    fallbackFormat?: "text" | "markdown";
+  }) {
+    this.cfg = params.cfg;
+    this.accountId = params.accountId;
+    this.account = resolveInfoflowAccount({ cfg: params.cfg, accountId: params.accountId });
+    this.to = params.to;
+    this.answerFormat = params.answerFormat ?? "markdown";
+    this.fallbackFormat = params.fallbackFormat ?? "markdown";
+  }
+
+  async start(): Promise<boolean> {
+    const content = buildCardContent({
+      answerText: "",
+      answerFormat: this.answerFormat,
+      phaseHistory: this.phaseHistory,
+      reasoningText: "",
+      toolEntries: [],
+      statusInfo: DEFAULT_PENDING_STATUS,
+      phaseLabel: DEFAULT_PENDING_STATUS,
+      done: false,
+      failed: false,
+    });
+    const result = await createStreamingCard({
+      account: this.account,
+      to: this.to,
+      content,
+    });
+    if (!result.ok || !result.modifyToken) {
+      this.failed = true;
+      this.createError = result.error ?? "create streaming card failed";
+      return false;
+    }
+    this.started = true;
+    this.modifyToken = result.modifyToken;
+    return true;
+  }
+
+  isUsable(): boolean {
+    return this.started && !this.failed && !!this.modifyToken;
+  }
+
+  fallbackMessageFormat(): "text" | "markdown" {
+    return this.fallbackFormat;
+  }
+
+  noteAssistantText(text?: string): void {
+    if (!this.isUsable() || text == null) {
+      return;
+    }
+    this.assistantText = mergeStreamingSnapshot(this.assistantText, text);
+    this.sawAssistantStream = true;
+    this.setPhase(DEFAULT_THINKING_STATUS);
+    this.scheduleFlush();
+  }
+
+  noteReasoning(text?: string): void {
+    if (!this.isUsable() || !text) {
+      return;
+    }
+    this.reasoningText = mergeStreamingSnapshot(this.reasoningText, text);
+    this.setPhase(DEFAULT_THINKING_STATUS);
+    this.scheduleFlush();
+  }
+
+  noteToolStart(payload: { name?: string; phase?: string }): void {
+    if (!this.isUsable()) {
+      return;
+    }
+    const name = payload.name?.trim() || "工具";
+    const phase = payload.phase === "update" ? "进行中" : "开始执行";
+    this.pushToolEntry(name, `- 状态: ${phase}`);
+    this.setPhase(DEFAULT_THINKING_STATUS);
+    this.scheduleFlush();
+  }
+
+  noteToolResult(text?: string): void {
+    if (!this.isUsable() || !text?.trim()) {
+      return;
+    }
+    this.appendActiveToolDetail(text.trim(), true);
+    this.setPhase(DEFAULT_THINKING_STATUS);
+    this.scheduleFlush();
+  }
+
+  async handleDeliveredPayload(params: {
+    kind: "tool" | "block" | "final";
+    payload: { text?: string; mediaUrls?: string[]; mediaUrl?: string };
+  }): Promise<boolean> {
+    if (!this.isUsable()) {
+      return false;
+    }
+    if (params.kind === "tool") {
+      this.noteToolResult(params.payload.text);
+      if (params.payload.mediaUrls?.length) {
+        for (const mediaUrl of params.payload.mediaUrls) {
+          this.appendActiveToolDetail(`- 附件: ${mediaUrl}`, true);
+        }
+        this.scheduleFlush();
+      }
+      return true;
+    }
+    if (params.payload.text && !this.sawAssistantStream) {
+      this.assistantText = params.payload.text;
+      this.setPhase(DEFAULT_THINKING_STATUS);
+      this.scheduleFlush();
+    }
+    if (params.payload.mediaUrls?.length) {
+      const existing = this.assistantText.trim();
+      const mediaSection = params.payload.mediaUrls.map((url) => `- ${url}`).join("\n");
+      this.assistantText = existing
+        ? `${existing}\n\n## 附件\n${mediaSection}`
+        : `## 附件\n${mediaSection}`;
+      this.scheduleFlush();
+    }
+    if (params.kind === "final") {
+      await this.complete();
+    }
+    return true;
+  }
+
+  async complete(): Promise<void> {
+    if (!this.isUsable()) {
+      return;
+    }
+    this.completed = true;
+    this.setPhase(DEFAULT_DONE_STATUS);
+    await this.flushNow();
+  }
+
+  async failWithMessage(message: string): Promise<void> {
+    if (!this.started || !this.modifyToken) {
+      this.failed = true;
+      return;
+    }
+    this.completed = true;
+    this.setPhase(DEFAULT_FAILED_STATUS);
+    if (!this.assistantText.trim()) {
+      this.assistantText = message;
+    }
+    await this.flushNow();
+    this.failed = true;
+  }
+
+  async fallbackSendFinalText(text: string): Promise<void> {
+    await sendInfoflowMessage({
+      cfg: this.cfg,
+      to: this.to,
+      accountId: this.accountId,
+      contents: [{ type: this.fallbackFormat, content: text }],
+    });
+  }
+
+  private setPhase(label: string): void {
+    this.statusInfo = label;
+    this.phaseLabel = label;
+    if (this.phaseHistory[this.phaseHistory.length - 1] !== label) {
+      this.phaseHistory.push(label);
+      if (this.phaseHistory.length > MAX_PHASE_ENTRIES) {
+        this.phaseHistory.splice(0, this.phaseHistory.length - MAX_PHASE_ENTRIES);
+      }
+    }
+  }
+
+  private pushToolEntry(name: string, detail: string): void {
+    const trimmedName = name.trim() || "工具";
+    const trimmedDetail = truncateTail(detail.trim(), 1_200);
+    const entry: ToolTrace = {
+      id: this.nextToolTraceId++,
+      name: trimmedName,
+      status: "running",
+      details: trimmedDetail ? [trimmedDetail] : [],
+    };
+    this.toolEntries.push(entry);
+    this.activeToolTraceId = entry.id;
+    if (this.toolEntries.length > MAX_TOOL_ENTRIES) {
+      this.toolEntries.splice(0, this.toolEntries.length - MAX_TOOL_ENTRIES);
+    }
+  }
+
+  private appendActiveToolDetail(text: string, markDone = false): void {
+    const trimmed = truncateTail(text.trim(), 1_200);
+    if (!trimmed) {
+      return;
+    }
+    const active =
+      (this.activeToolTraceId != null
+        ? this.toolEntries.find((entry) => entry.id === this.activeToolTraceId)
+        : undefined) ?? this.toolEntries[this.toolEntries.length - 1];
+    if (!active) {
+      this.pushToolEntry("工具", trimmed);
+      return;
+    }
+    active.details.push(trimmed);
+    if (markDone) {
+      active.status = "done";
+    }
+  }
+
+  private scheduleFlush(): void {
+    if (this.flushTimer) {
+      return;
+    }
+    this.flushTimer = setTimeout(() => {
+      this.flushTimer = undefined;
+      void this.flushNow();
+    }, STREAMING_FLUSH_INTERVAL_MS);
+  }
+
+  private async flushNow(): Promise<void> {
+    if (this.flushTimer) {
+      clearTimeout(this.flushTimer);
+      this.flushTimer = undefined;
+    }
+    if (!this.isUsable()) {
+      return;
+    }
+    if (this.flushPromise) {
+      this.flushQueued = true;
+      await this.flushPromise;
+      return;
+    }
+    this.flushQueued = false;
+    const answerText = this.assistantText.trim();
+    const content = buildCardContent({
+      answerText,
+      answerFormat: this.answerFormat,
+      phaseHistory: this.phaseHistory,
+      reasoningText: this.reasoningText,
+      toolEntries: this.toolEntries,
+      statusInfo: this.statusInfo,
+      phaseLabel: this.phaseLabel,
+      done: this.completed,
+      failed: this.phaseLabel === DEFAULT_FAILED_STATUS,
+    });
+    this.flushPromise = updateStreamingCard({
+      account: this.account,
+      to: this.to,
+      modifyToken: this.modifyToken!,
+      content,
+      groupVersion: /^group:\d+$/i.test(this.to) ? this.groupUpdateVersion++ : undefined,
+    })
+      .then(async (result) => {
+        if (!result.ok) {
+          this.failed = true;
+          this.createError = result.error;
+          getInfoflowSendLog().error(`[streaming] update failed: ${result.error}`);
+        }
+      })
+      .finally(() => {
+        this.flushPromise = undefined;
+      });
+    await this.flushPromise;
+    if (this.flushQueued && this.isUsable()) {
+      this.flushQueued = false;
+      await this.flushNow();
+    }
+  }
+}
+
+export function normalizeStreamingFallbackFormat(
+  format: InfoflowMessageFormat | undefined,
+): "text" | "markdown" {
+  return format === "text" ? "text" : "markdown";
+}
+
+export async function sendStreamingFallbackError(params: {
+  cfg: OpenClawConfig;
+  to: string;
+  accountId?: string;
+  error: unknown;
+}): Promise<void> {
+  const message = `处理出错，请稍后重试\n${formatInfoflowError(params.error)}`;
+  try {
+    await sendInfoflowMessage({
+      cfg: params.cfg,
+      to: params.to,
+      accountId: params.accountId,
+      contents: [{ type: "text", content: message }],
+    });
+  } catch (err) {
+    logVerbose(`[streaming] fallback error message failed: ${formatInfoflowError(err)}`);
+  }
+}