@downcity/agent 1.1.32 → 1.1.43

package/src/session/README.md

@@ -1,108 +0,0 @@
-# Session Module
-
-`session/` 是单 Agent 会话执行内核。它不直接面向普通 SDK 用户；普通用户通过 `sdk/Session.ts` 使用 `session.prompt()`、`session.subscribe()`、`session.history()` 等 API。
-
-## 核心概念
-
-- `Session`：用户/SDK 面向的完整会话对象，负责模型配置、历史入口、prompt 入口和分叉能力。
-- `Executor`：单个 session 的内部单轮执行引擎，负责并发锁、执行 scope、Composer 编排、压缩重试、assistant step 持久化和 tool-loop 调用。
-- `Composer`：执行前的材料组装协议，只负责把原材料组装成某一阶段输入，不直接执行模型，也没有公共运行时基类。
-- `HistoryStore`：历史事实源，负责 JSONL 读写、meta、archive、lock、compact 与消息工厂。
-- `HistoryComposer`：历史组装策略，只负责把 `HistoryStore` 中的历史组装成本轮模型输入。
-- `CoreEngine`：Executor 内部的模型/tool-loop 核心机制，负责模型流、tool calls、续写和最终 assistant message 合并。
-
-## 一轮 prompt 的调用链
-
-```text
-sdk/Session.prompt({ query })
-  -> SessionPromptRuntime 绑定 turn
-  -> append user message
-  -> session/Executor 执行当前 turn
-     -> ContextComposer.compose()
-     -> SystemComposer.resolve()
-     -> CompactionComposer.run()
-     -> HistoryComposer.prepare()
-     -> Executor.runCoreEngine()
-        -> ai.streamText({ model, system, messages, tools })
-     -> return assistantMessage
-  -> append final assistant message
-  -> resolve turn.finished
-```
-
-## Composer 分工
-
-- `composer/system/`：组装本轮 system messages，例如 instruction、service system、plugin system 和 session context。
-- `composer/history/`：只组装本轮 model messages，不负责历史落盘。
-- `composer/context/`：组装 tools、step hooks、fallback assistant message 等运行上下文。
-- `composer/compaction/`：判断上下文错误和压缩历史，必要时写入 summary 与 archive。
-
-## Composer 的代码实现方式
-
-Composer 在代码里是 TypeScript `interface`，不是抽象基类。每个 Composer 只声明当前阶段需要的最小协议，实现类用 `implements` 接上。
-
-```ts
-export interface SessionSystemComposer {
-  readonly name: string;
-  resolve(): Promise<SystemModelMessage[]>;
-}
-
-export class DefaultSessionSystemComposer implements SessionSystemComposer {
-  readonly name = "prompt_system";
-
-  async resolve() {
-    // 关键点（中文）：只组装 system messages，不执行模型、不写历史。
-  }
-}
-```
-
-当前四类协议分别回答四个问题：
-
-- `SessionSystemComposer.resolve()`：这一轮 system messages 是什么？
-- `SessionHistoryComposer.prepare()`：这一轮喂给模型的 history messages 是什么？
-- `SessionContextComposer.compose()`：这一轮有哪些 tools 与 step hooks？
-- `SessionCompactionComposer.run()`：是否需要压缩，以及压缩策略是什么？
-
-`Executor.prepareExecuteInput()` 是 Composer 的唯一主装配点：
-
-```text
-Executor.prepareExecuteInput()
-  -> ContextComposer.compose()
-  -> SystemComposer.resolve()
-  -> CompactionComposer.run(historyStore)
-  -> HistoryComposer.prepare()
-  -> SessionExecuteInput
-```
-
-边界规则：
-
-- Composer 不调用模型，模型调用只发生在 `Executor.runCoreEngine()`。
-- Composer 不持有历史事实，历史事实由 `HistoryStore` 负责。
-- Composer 不管理 session 生命周期，生命周期由 `Session` / `Executor` 管理。
-- Composer 可以读取上下文并做策略判断，但输出应该是“本轮执行材料”。
-
-## 当前目录结构
-
-```text
-session/
-├── Executor.ts
-├── SessionRunScope.ts
-├── composer/
-│   ├── compaction/
-│   ├── context/
-│   ├── history/
-│   └── system/
-├── core-engine/
-│   ├── CoreEngineMessageState.ts
-│   ├── CoreEngineLoopDecision.ts
-│   ├── CoreEngineSignals.ts
-│   ├── CoreEngineError.ts
-│   └── CoreEngineUiStreamCollector.ts
-├── store/
-│   └── history/
-│       ├── SessionHistoryStore.ts
-│       └── jsonl/JsonlSessionHistoryStore.ts
-├── ids/
-├── messages/
-├── tools/
-└── types/
-```

package/src/session/SessionRunScope.ts

@@ -1,146 +0,0 @@
-import { AsyncLocalStorage } from "node:async_hooks";
-import type { SessionUserMessageV1 } from "@/session/types/SessionMessages.js";
-import type {
-  SessionAssistantStepCallback,
-  SessionUiMessageChunkCallback,
-} from "@/session/types/SessionRun.js";
-
-/**
- * SessionRunScope（单次请求作用域）。
- *
- * 关键点（中文）
- * - 这是 session run 层请求作用域上下文，不属于具体 service 模块。
- * - 统一承载请求链需要透传的字段（如 `sessionId`）。
- */
-export type SessionRunScope = {
-  sessionId?: string;
-  /**
-   * step 边界合并回调（可选）。
-   *
-   * 关键点（中文）
-   * - 由调用侧（如 chat queue）注入。
-   * - Orchestrator 从 SessionRunScope 读取并编排到本轮运行上下文。
-   */
-  onStepCallback?: () => Promise<SessionUserMessageV1[]>;
-
-  /**
-   * assistant step 完成回调（可选）。
-   *
-   * 关键点（中文）
-   * - 在每个 LLM step 结束时触发。
-   * - 用于把中间文本增量派发到外部通道（如 direct 模式分步发送）。
-   */
-  onAssistantStepCallback?: SessionAssistantStepCallback;
-
-  /**
-   * UI stream chunk 回调（可选）。
-   *
-   * 关键点（中文）
-   * - 用于把底层模型 UI stream 事件向上层 SDK / transport 旁路输出。
-   * - 不影响最终 assistantMessage 的收敛与落盘。
-   */
-  onUiMessageChunkCallback?: SessionUiMessageChunkCallback;
-
-  /**
-   * 运行时注入的 user 消息队列（可选）。
-   *
-   * 关键点（中文）
-   * - 用于在 tool 执行后向下一 step 注入结构化 user 消息。
-   * - 队列内容由 service 侧通过统一协议下发，main 不感知业务语义。
-   */
-  injectedUserMessages?: SessionUserMessageV1[];
-};
-
-/**
- * AsyncLocalStorage 容器（请求作用域）。
- *
- * 关键点（中文）
- * - 同一条异步调用链内可读取一致的 SessionRunScope。
- * - 用于把 `sessionId` 从入口透传到 service 与工具层。
- */
-export const sessionRunScopeStorage = new AsyncLocalStorage<SessionRunScope>();
-
-/**
- * 待持久化的运行时注入 user 消息队列（按 sessionId）。
- *
- * 关键点（中文）
- * - sessionRunScopeStorage 中的 injectedUserMessages 只负责“下一 step 临时可见”。
- * - 为了让时间线顺序稳定，这里把“真正写入历史”的动作延后到
- *   assistant message 落盘之后再统一执行。
- */
-const deferredPersistedUserMessagesBySession = new Map<
-  string,
-  SessionUserMessageV1[]
->();
-
-/**
- * 在当前异步调用链内绑定 session run 作用域。
- */
-export function withSessionRunScope<T>(ctx: SessionRunScope, fn: () => T): T {
-  return sessionRunScopeStorage.run(ctx, fn);
-}
-
-/**
- * 读取当前异步链路上的 session run 作用域。
- */
-export function getSessionRunScope(): SessionRunScope | undefined {
-  return sessionRunScopeStorage.getStore();
-}
-
-/**
- * 入队一条“待注入 user 消息”。
- *
- * 关键点（中文）
- * - 若当前不在 session run 作用域内，静默忽略（fail-open）。
- */
-export function enqueueInjectedUserMessage(
-  message: SessionUserMessageV1,
-): void {
-  const store = sessionRunScopeStorage.getStore();
-  if (!store || !message) return;
-  if (!Array.isArray(store.injectedUserMessages)) {
-    store.injectedUserMessages = [];
-  }
-  store.injectedUserMessages.push(message);
-}
-
-/**
- * 读取并清空“待注入 user 消息”队列。
- *
- * 关键点（中文）
- * - 采用 drain 语义，确保每条注入消息只在下一 step 使用一次。
- */
-export function drainInjectedUserMessages(): SessionUserMessageV1[] {
-  const store = sessionRunScopeStorage.getStore();
-  if (!store || !Array.isArray(store.injectedUserMessages)) return [];
-  const out = [...store.injectedUserMessages];
-  store.injectedUserMessages = [];
-  return out;
-}
-
-/**
- * 入队一条“待持久化 user 消息”。
- */
-export function enqueueDeferredPersistedUserMessage(
-  sessionId: string,
-  message: SessionUserMessageV1,
-): void {
-  const key = String(sessionId || "").trim();
-  if (!key || !message) return;
-  const current = deferredPersistedUserMessagesBySession.get(key) || [];
-  current.push(message);
-  deferredPersistedUserMessagesBySession.set(key, current);
-}
-
-/**
- * 读取并清空指定 session 的待持久化 user 消息。
- */
-export function drainDeferredPersistedUserMessages(
-  sessionId: string,
-): SessionUserMessageV1[] {
-  const key = String(sessionId || "").trim();
-  if (!key) return [];
-  const current = deferredPersistedUserMessagesBySession.get(key) || [];
-  deferredPersistedUserMessagesBySession.delete(key);
-  return [...current];
-}

package/src/session/composer/compaction/SessionCompactionComposer.ts

@@ -1,62 +0,0 @@
-/**
- * SessionCompactionComposer：上下文压缩 Composer 抽象。
- *
- * 关键点（中文）
- * - 负责“何时压缩 + 压缩策略参数”决策。
- * - 具体读写由 SessionHistoryStore 执行（CompactionComposer 不直接落盘）。
- */
-
-import type { LanguageModel, SystemModelMessage } from "ai";
-import type { SessionHistoryStore } from "@/session/store/history/SessionHistoryStore.js";
-
-/**
- * compaction Composer 执行输入。
- */
-export type SessionCompactionInput = {
-  /**
-   * 当前会话 history Store。
-   */
-  historyStore: SessionHistoryStore;
-
-  /**
-   * 当前模型实例。
-   */
-  model: LanguageModel;
-
-  /**
-   * 当前轮 system messages。
-   */
-  system: SystemModelMessage[];
-
-  /**
-   * 当前重试次数（由 Executor 递增）。
-   */
-  retryCount: number;
-};
-
-/**
- * Compaction Composer 协议。
- */
-export interface SessionCompactionComposer {
-  /**
-   * Composer 名（由具体实现声明）。
-   */
-  readonly name: string;
-
-  /**
-   * 执行 compact（best-effort）。
-   */
-  run(input: SessionCompactionInput): Promise<{
-    compacted: boolean;
-    reason?: string;
-  }>;
-
-  /**
-   * 判断某次执行错误是否应该触发“压缩后重试”。
-   *
-   * 关键点（中文）
-   * - 由 compaction Composer 实现侧维护错误识别策略。
-   * - Executor 不感知具体错误文案，只按该布尔结果决定是否重试。
-   */
-  shouldCompactOnError(error: unknown): boolean;
-}

package/src/session/composer/compaction/jsonl/JsonlSessionCompactionComposer.ts

@@ -1,101 +0,0 @@
-/**
- * JsonlSessionCompactionComposer：默认上下文压缩 Composer。
- *
- * 关键点（中文）
- * - 只负责压缩参数策略（retry 越多，窗口越紧）。
- * - 真正的读写与 compact 执行交由 history Store。
- */
-
-import type {
-  SessionCompactionComposer,
-  SessionCompactionInput,
-} from "@session/composer/compaction/SessionCompactionComposer.js";
-
-type JsonlSessionCompactionComposerOptions = {
-  keepLastMessages?: number;
-  maxInputTokensApprox?: number;
-  archiveOnCompact?: boolean;
-  compactRatio?: number;
-};
-
-/**
- * JsonlSessionCompactionComposer 默认实现。
- */
-export class JsonlSessionCompactionComposer implements SessionCompactionComposer {
-  readonly name = "summary_compaction_composer";
-  private readonly options: JsonlSessionCompactionComposerOptions;
-
-  constructor(options?: JsonlSessionCompactionComposerOptions) {
-    this.options = options || {};
-  }
-
-  private resolvePolicy(retryCount: number): {
-    keepLastMessages: number;
-    maxInputTokensApprox: number;
-    archiveOnCompact: boolean;
-    compactRatio: number;
-  } {
-    const baseKeepLastMessages =
-      typeof this.options.keepLastMessages === "number"
-        ? Math.max(6, Math.min(5000, Math.floor(this.options.keepLastMessages)))
-        : 30;
-    const baseMaxInputTokensApprox =
-      typeof this.options.maxInputTokensApprox === "number"
-        ? Math.max(2000, Math.min(200_000, Math.floor(this.options.maxInputTokensApprox)))
-        : 128000;
-    const retryFactor = Math.max(1, Math.pow(2, retryCount));
-    const keepLastMessages = Math.max(6, Math.floor(baseKeepLastMessages / retryFactor));
-    const maxInputTokensApprox = Math.max(
-      2000,
-      Math.floor(baseMaxInputTokensApprox / retryFactor),
-    );
-    const archiveOnCompact =
-      this.options.archiveOnCompact === undefined
-        ? true
-        : Boolean(this.options.archiveOnCompact);
-    const compactRatioRaw =
-      typeof this.options.compactRatio === "number" &&
-      Number.isFinite(this.options.compactRatio)
-        ? this.options.compactRatio
-        : 0.5;
-    const compactRatio = Math.max(0.1, Math.min(0.9, compactRatioRaw));
-    return {
-      keepLastMessages,
-      maxInputTokensApprox,
-      archiveOnCompact,
-      compactRatio,
-    };
-  }
-
-  async run(input: SessionCompactionInput): Promise<{
-    compacted: boolean;
-    reason?: string;
-  }> {
-    const policy = this.resolvePolicy(input.retryCount);
-    return await input.historyStore.compact({
-      model: input.model,
-      system: input.system,
-      keepLastMessages: policy.keepLastMessages,
-      maxInputTokensApprox: policy.maxInputTokensApprox,
-      archiveOnCompact: policy.archiveOnCompact,
-      compactRatio: policy.compactRatio,
-    });
-  }
-
-  /**
-   * 判断错误是否属于“应先 compact 再重试”的类型。
-   *
-   * 关键点（中文）
-   * - 当前实现基于主流模型 provider 的超限关键词。
-   * - 后续若接入新 provider，可在此处统一扩展识别规则。
-   */
-  shouldCompactOnError(error: unknown): boolean {
-    const errorMsg = String(error ?? "");
-    return (
-      errorMsg.includes("context_length") ||
-      errorMsg.includes("too long") ||
-      errorMsg.includes("maximum context") ||
-      errorMsg.includes("context window")
-    );
-  }
-}

package/src/session/composer/compaction/jsonl/JsonlSessionCompactionExecutor.ts

@@ -1,261 +0,0 @@
-/**
- * JsonlSessionCompactionExecutor：JSONL session 压缩执行模块。
- *
- * 关键职责（中文）
- * - 评估当前消息是否超出输入预算。
- * - 在锁外生成“更早历史摘要”，降低锁持有时间。
- * - 在锁内完成归档与 messages.jsonl 重写，保证并发安全。
- */
-
-import fs from "fs-extra";
-import path from "node:path";
-import {
-  generateText,
-  isTextUIPart,
-  type LanguageModel,
-  type SystemModelMessage,
-} from "ai";
-import { generateId } from "@/utils/Id.js";
-import { getLogger } from "@/utils/logger/Logger.js";
-import type {
-  SessionMessageV1,
-  SessionMetadataV1,
-} from "@/session/types/SessionMessages.js";
-import type { SessionHistoryMetaV1 } from "@/session/types/SessionHistoryMeta.js";
-
-export type SessionCompactParams = {
-  model: LanguageModel;
-  system: Array<SystemModelMessage>;
-  keepLastMessages: number;
-  maxInputTokensApprox: number;
-  archiveOnCompact: boolean;
-  compactRatio: number;
-};
-
-type SessionCompactDeps = {
-  rootPath: string;
-  sessionId: string;
-  withWriteLock: <T>(fn: () => Promise<T>) => Promise<T>;
-  loadAll: () => Promise<SessionMessageV1[]>;
-  createSummaryMessage: (params: {
-    text: string;
-    sourceRange?: SessionMetadataV1["sourceRange"];
-  }) => SessionMessageV1;
-  getArchiveDirPath: () => string;
-  getMessagesFilePath: () => string;
-  readMetaUnsafe: () => Promise<SessionHistoryMetaV1>;
-  writeMetaUnsafe: (next: SessionHistoryMetaV1) => Promise<void>;
-};
-
-/**
- * 对当前 session messages 做一次 best-effort compact（必要时）。
- *
- * 注意（中文）
- * - compact 会 rewrite `messages.jsonl`（不是纯 append-only），因此必须防并发覆盖
- * - 这里做两阶段锁：先 snapshot 再生成摘要，最后再锁定写入，降低锁持有时间
- */
-export async function compactSessionMessagesIfNeeded(
-  deps: SessionCompactDeps,
-  params: SessionCompactParams,
-): Promise<{ compacted: boolean; reason?: string }> {
-  const logger = getLogger(deps.rootPath, "info");
-
-  // 算法阶段（中文）
-  // phase 1：snapshot（短锁）
-  // - 仅负责拿一致性快照，不做耗时的模型调用。
-  // - 目的是把锁持有时间降到最低。
-  let snapshot: SessionMessageV1[] = [];
-  let snapshotTailId = "";
-  await deps.withWriteLock(async () => {
-    snapshot = await deps.loadAll();
-    snapshotTailId =
-      snapshot.length > 0
-        ? String(snapshot[snapshot.length - 1].id || "")
-        : "";
-  });
-
-  if (snapshot.length < 4) {
-    return { compacted: false, reason: "small_messages" };
-  }
-
-  const systemText = (params.system || [])
-    .map((m) => String(m.content ?? ""))
-    .join("\n\n");
-  // 关键点（中文）：session messages 现在可能包含 tool parts / output，必须把它们计入预算估算，否则会低估 token。
-  let messagesJson = "";
-  try {
-    messagesJson = JSON.stringify(snapshot);
-  } catch {
-    messagesJson = "";
-  }
-  const est = estimateTokensApproxFromText(systemText + "\n\n" + messagesJson);
-  if (est <= params.maxInputTokensApprox) {
-    return { compacted: false, reason: "under_budget" };
-  }
-
-  // 关键点（中文）：触发 compact 后，优先压缩“最早一段消息”，默认比例 50%。
-  const compactRatio = normalizeCompactRatio(params.compactRatio);
-  const compactCount = resolveCompactCount(snapshot.length, compactRatio);
-  const older = snapshot.slice(0, compactCount);
-  if (older.length === 0) return { compacted: false, reason: "nothing_to_compact" };
-
-  const olderTextAll = extractPlainTextFromMessages(older);
-  const maxOlderChars = 24_000;
-  const olderText =
-    olderTextAll.length > maxOlderChars
-      ? "（注意：更早历史过长，已截断保留末尾）\n" + olderTextAll.slice(-maxOlderChars)
-      : olderTextAll;
-
-  // phase 1.5：生成摘要（不持锁）
-  // - 这一步最耗时，必须在锁外执行，避免阻塞 append。
-  let summary = "";
-  try {
-    const r = await generateText({
-      model: params.model,
-      system: [
-        {
-          role: "system",
-          content:
-            "你是对话压缩助手。请把更早的对话历史压缩成“可持续复用”的工作摘要。\n" +
-            "要求：\n" +
-            "- 输出中文\n" +
-            "- 不要复述无关细节，不要输出工具原始日志\n" +
-            "- 必须包含：已确认事实/用户偏好约束/已做决策/未完成事项\n" +
-            "- 使用 Markdown 列表，控制在 300~800 字",
-        },
-      ],
-      prompt: `请压缩以下更早历史（按 user/assistant 交替记录）：\n\n${olderText}`,
-    });
-    summary = String(r.text || "").trim();
-  } catch (e) {
-    await logger.log(
-      "warn",
-      "Session messages compact summary failed, fallback to lossy truncation",
-      {
-        sessionId: deps.sessionId,
-        error: String(e),
-      },
-    );
-    summary = "（系统自动压缩：摘要生成失败，已丢弃更早历史，仅保留最近对话。）";
-  }
-
-  const fromId = String(older[0]?.id || "");
-  const toId = String(older[older.length - 1]?.id || "");
-  const summaryMsg = deps.createSummaryMessage({
-    text: summary,
-    sourceRange: fromId && toId ? { fromId, toId, count: older.length } : undefined,
-  });
-
-  const archiveId = `compact-${Date.now()}-${generateId()}`;
-
-  // phase 2：写入（短锁，且避免覆盖新追加）
-  // - 以“当前最新 session messages”为准重算 currentOlder / currentKept，避免覆盖并发新消息。
-  await deps.withWriteLock(async () => {
-    const current = await deps.loadAll();
-    if (!current.length) return;
-
-    // 如果 tail 不同，说明期间有新消息追加；我们仍可安全 compact：按“当前长度 + 相同比例”重算。
-    // snapshotTailId 用于 debug，不作为强一致性依赖。
-    void snapshotTailId;
-
-    const currentCompactCount = resolveCompactCount(current.length, compactRatio);
-    const currentOlder = current.slice(0, currentCompactCount);
-    const currentKept = current.slice(currentCompactCount);
-    if (currentOlder.length === 0) return;
-
-    if (params.archiveOnCompact) {
-      const archivePath = path.join(
-        deps.getArchiveDirPath(),
-        `${encodeURIComponent(String(archiveId || "").trim())}.json`,
-      );
-      await fs.writeJson(
-        archivePath,
-        {
-          v: 1,
-          sessionId: deps.sessionId,
-          archivedAt: Date.now(),
-          messages: currentOlder,
-        },
-        { spaces: 2 },
-      );
-    }
-
-    const next = [summaryMsg, ...currentKept];
-
-    const messagesPath = deps.getMessagesFilePath();
-    const tmp = messagesPath + ".tmp";
-    await fs.writeFile(tmp, next.map((m) => JSON.stringify(m)).join("\n") + "\n", "utf8");
-    await fs.move(tmp, messagesPath, { overwrite: true });
-
-    const prevMeta = await deps.readMetaUnsafe();
-    await deps.writeMetaUnsafe({
-      ...prevMeta,
-      updatedAt: Date.now(),
-      lastArchiveId: params.archiveOnCompact ? archiveId : undefined,
-      keepLastMessages: Math.max(1, currentKept.length),
-      maxInputTokensApprox: params.maxInputTokensApprox,
-      compactRatio,
-    });
-  });
-
-  return { compacted: true };
-}
-
-/**
- * 归一化压缩比例。
- *
- * 关键点（中文）
- * - 仅允许 0.1~0.9，避免“几乎不压缩”或“几乎全压缩”。
- */
-function normalizeCompactRatio(value: number): number {
-  if (!Number.isFinite(value)) return 0.5;
-  return Math.max(0.1, Math.min(0.9, value));
-}
-
-/**
- * 按比例计算前段压缩条数。
- *
- * 关键点（中文）
- * - 至少压缩 1 条；
- * - 至少保留 1 条未压缩消息。
- */
-function resolveCompactCount(total: number, ratio: number): number {
-  const n = Math.max(0, Math.floor(total));
-  if (n <= 1) return 0;
-  const raw = Math.floor(n * ratio);
-  return Math.max(1, Math.min(n - 1, raw));
-}
-
-/**
- * 近似 token 估算。
- *
- * 算法说明（中文）
- * - 这里使用经验近似，不追求精确 tokenizer 一致性。
- * - 目标是为 compact 提供保守预算，宁可略高估也不要低估。
- */
-function estimateTokensApproxFromText(text: string): number {
-  const t = String(text || "");
-  // 经验值：英文 ~4 chars/token；中文更接近 1-2 chars/token。这里用保守的 3 chars/token。
-  return Math.ceil(t.length / 3);
-}
-
-/**
- * 从 UIMessage 提取可摘要的纯文本。
- *
- * 关键点（中文）
- * - 统一把 user / assistant 内容线性化，作为 compact 摘要输入。
- * - tool 原始结构不会原样输出，避免把噪声日志喂给摘要模型。
- */
-function extractPlainTextFromMessages(messages: SessionMessageV1[]): string {
-  const lines: string[] = [];
-  for (const m of messages) {
-    if (!m || typeof m !== "object") continue;
-    const role = m.role === "user" ? "user" : "assistant";
-    const parts = Array.isArray(m.parts) ? m.parts : [];
-    const textParts = parts.filter(isTextUIPart).map((p) => String(p.text ?? ""));
-    const text = textParts.join("\n").trim();
-    if (!text) continue;
-    lines.push(`${role}: ${text}`);
-  }
-  return lines.join("\n");
-}