@morlay/ui-conversation-message-actions 0.0.12 → 0.0.14-alpha.0

package/src/index.ts

@@ -1,5 +1,5 @@
 import { Service, type Context } from "@deepseek-ai/cordis";
-import type { AssistantMessage, ContentBlock, UserMessage } from "@deepseek-ai/dsh-llm";
+import type { AssistantMessage, UserMessage } from "@deepseek-ai/dsh-llm";
 import type {
   Session,
   SessionEvent,
@@ -7,16 +7,11 @@ import type {
   SurfaceEventType,
   SurfaceIntent,
 } from "@deepseek-ai/dsh-session";
-import { randomUUID } from "node:crypto";
 import {
-  SESSION_BRANCH_VERSION_SCHEMA,
   SessionBranchError,
   balanceRewindPrefix,
   type BranchBoundary,
   type BranchTimeline,
-  type EditableBlockKind,
-  type SessionBranchEffect,
-  type SessionBranchVersionEvent,
 } from "@morlay/session-branch";
 import type {
   EditOperation,
@@ -33,6 +28,14 @@ import {
   type SessionEditorTimeline,
   toTimelinePayload,
 } from "./shared.ts";
+import {
+  closedTurns,
+  editableMessages,
+  editPlan,
+  retryPlan,
+  rerollPlan,
+  retryableTurns,
+} from "./plan.ts";
 
 export type { CascadePolicy, EditableBlockKind } from "@morlay/session-branch";
 export type {
@@ -60,6 +63,16 @@ declare module "@deepseek-ai/cordis" {
 export interface EditorAgent {
   readonly session: Session;
   followup(message: UserMessage): void;
+  /** 等待 agent 到达 quiescence（当前 turn/任务结束后 resolve）。 */
+  whenIdle(): Promise<void>;
+  /**
+   * 队列中是否有待处理输入（next-turn / next-step）。rewind 截断会删除这些
+   * 输入所属轮次的事件，残留的 inbox 状态会与截断后的 log 失配，使后续
+   * splice 落库后无法从日志重放——编辑前必须清空。
+   */
+  readonly inboxPending: boolean;
+  /** 清空待处理输入（落库 canceled splice，须在 rewind 前调用）。 */
+  clearInbox(): void;
 }
 
 export interface EditorAgentHandle {
@@ -87,306 +100,6 @@ export interface EditorAgentRegistry {
   }): Promise<EditorAgentHandle>;
 }
 
-interface ClosedTurn {
-  turn: number;
-  startSeq: number;
-
-  endSeq?: number;
-
-  closed: boolean;
-  user?: SessionEvent<"user/message">;
-  assistants: SessionEvent<"assistant/message">[];
-}
-
-function closedTurns(events: readonly SessionEvent[]): ClosedTurn[] {
-  const result: ClosedTurn[] = [];
-  let current: Omit<ClosedTurn, "endSeq" | "closed"> | undefined;
-  for (const event of events) {
-    if (event.type === "turn/start") {
-      current = { turn: event.data.turn, startSeq: event.seq, assistants: [] };
-      continue;
-    }
-    if (current === undefined) continue;
-    if (
-      event.type === "user/message" &&
-      current.user === undefined &&
-      event.data.source.kind === "user"
-    ) {
-      current.user = event;
-      continue;
-    }
-    if (event.type === "assistant/message" && event.data.turn === current.turn) {
-      current.assistants.push(event);
-      continue;
-    }
-    if (event.type === "turn/end" && event.data.turn === current.turn) {
-      result.push({ ...current, endSeq: event.seq, closed: true });
-      current = undefined;
-    }
-  }
-  // 未闭合轮次（无 turn/end）也保留：user 消息已落定，编辑时 rewind 到该
-  // 消息（exclusive drop）重放即可。
-  if (current !== undefined) result.push({ ...current, closed: false });
-  return result;
-}
-
-function isTextualBlock(
-  block: ContentBlock | undefined,
-): block is Extract<ContentBlock, { type: "text" | "reasoning" }> {
-  return block?.type === "text" || block?.type === "reasoning";
-}
-
-function userText(message: UserMessage): string {
-  return message.content
-    .filter((block): block is Extract<ContentBlock, { type: "text" }> => block.type === "text")
-    .map((block) => block.text)
-    .join("\n");
-}
-
-function cloneUser(
-  message: UserMessage,
-  content: ContentBlock[] = structuredClone(message.content),
-): UserMessage {
-  return Object.freeze({
-    id: randomUUID(),
-    role: "user",
-    content: Object.freeze(content),
-    source: Object.freeze({ kind: "user" }),
-  }) as UserMessage;
-}
-
-function replaceTextBlock(
-  content: readonly ContentBlock[],
-  blockIndex: number,
-  text: string,
-): ContentBlock[] {
-  const block = content[blockIndex];
-  if (!isTextualBlock(block))
-    throw new SessionBranchError("所选内容块不是可编辑文本。", "INVALID_BOUNDARY");
-  return content.map((candidate, index) =>
-    index === blockIndex ? ({ ...candidate, text } as ContentBlock) : structuredClone(candidate),
-  );
-}
-
-function editableMessages(turns: readonly ClosedTurn[]): EditableMessageBlock[] {
-  const result: EditableMessageBlock[] = [];
-  for (const turn of turns) {
-    if (turn.user !== undefined) {
-      for (const [blockIndex, block] of turn.user.data.content.entries()) {
-        if (block.type !== "text") continue;
-        result.push({
-          key: `${String(turn.user.seq)}:${String(blockIndex)}`,
-          turn: turn.turn,
-          eventSeq: turn.user.seq,
-          blockIndex,
-          kind: "user",
-          text: block.text,
-          time: turn.user.time,
-        });
-      }
-    }
-    // 未闭合轮次的助手消息是流式 partial，不可编辑。
-    if (!turn.closed) continue;
-    for (const event of turn.assistants) {
-      for (const [blockIndex, block] of event.data.message.content.entries()) {
-        if (!isTextualBlock(block)) continue;
-        result.push({
-          key: `${String(event.seq)}:${String(blockIndex)}`,
-          turn: turn.turn,
-          eventSeq: event.seq,
-          blockIndex,
-          kind: block.type === "reasoning" ? "assistant.reasoning" : "assistant.response",
-          text: block.text,
-          time: event.time,
-        });
-      }
-    }
-  }
-  return result;
-}
-
-function retryableTurns(turns: readonly ClosedTurn[]): RetryableTurn[] {
-  return turns.flatMap((turn): RetryableTurn[] =>
-    // 未闭合轮次无已落定回复可重生成，不可重试。
-    turn.user === undefined || !turn.closed
-      ? []
-      : [
-          {
-            turn: turn.turn,
-            userEventSeq: turn.user.seq,
-            preview: userText(turn.user.data),
-            time: turn.user.time,
-          },
-        ],
-  );
-}
-
-function downstreamUsers(turns: readonly ClosedTurn[], start: number): UserMessage[] {
-  return turns
-    .slice(start)
-    .flatMap((turn): UserMessage[] => (turn.user === undefined ? [] : [cloneUser(turn.user.data)]));
-}
-
-function assistantReplacement(
-  event: SessionEvent<"assistant/message">,
-  blockIndex: number,
-  text: string,
-): AssistantMessage {
-  const replaced = replaceTextBlock(event.data.message.content, blockIndex, text).filter(
-    (block) => block.type === "text" || block.type === "reasoning",
-  );
-  return Object.freeze({
-    id: randomUUID(),
-    role: "assistant",
-    content: Object.freeze(replaced),
-    source: Object.freeze({
-      kind: "model",
-      provider: event.data.message.source.provider,
-      model: event.data.message.source.model,
-    }),
-  }) as AssistantMessage;
-}
-
-interface OperationPlan {
-  anchorSeq: number;
-
-  rewindBoundary?: number;
-  version: SessionBranchVersionEvent;
-
-  manualTurn?: { turn: number; user: UserMessage; assistant: AssistantMessage };
-
-  queuedUsers: UserMessage[];
-}
-
-function pairVersionEffect(
-  sourceSessionId: SessionId,
-  effect: Omit<SessionBranchEffect, "id">,
-): SessionBranchVersionEvent {
-  return {
-    schemaVersion: SESSION_BRANCH_VERSION_SCHEMA,
-    effect: { ...effect, id: randomUUID() },
-    inverse: { kind: "restore-version", sessionId: sourceSessionId },
-  };
-}
-
-function editPlan(operation: EditOperation, turns: readonly ClosedTurn[]): OperationPlan {
-  const turnIndex = turns.findIndex(
-    (turn) =>
-      operation.eventSeq > turn.startSeq &&
-      (turn.endSeq === undefined || operation.eventSeq < turn.endSeq),
-  );
-  const turn = turns[turnIndex];
-  if (turn === undefined)
-    throw new SessionBranchError("所选消息不属于已落定回合。", "INVALID_BOUNDARY");
-  const event =
-    turn.user?.seq === operation.eventSeq
-      ? turn.user
-      : turn.assistants.find((candidate) => candidate.seq === operation.eventSeq);
-  if (event === undefined)
-    throw new SessionBranchError("所选消息不存在或不可编辑。", "INVALID_BOUNDARY");
-
-  if (event.type === "user/message") {
-    const before = event.data.content[operation.blockIndex];
-    if (before?.type !== "text")
-      throw new SessionBranchError("所选用户消息块不是文本。", "INVALID_BOUNDARY");
-    const edited = cloneUser(
-      event.data,
-      replaceTextBlock(event.data.content, operation.blockIndex, operation.text),
-    );
-    const later = operation.cascade === "preserve" ? downstreamUsers(turns, turnIndex + 1) : [];
-    return {
-      anchorSeq: turn.startSeq,
-      // 未闭合轮次：rewind 到该 user 消息（exclusive drop），由编辑版替换；
-      // 闭合轮次走前一轮 turn/end 的 inclusive 语义。
-      ...(turn.closed ? {} : { rewindBoundary: event.seq }),
-      version: pairVersionEffect(operation.sessionId, {
-        operation: "edit",
-        cascade: operation.cascade,
-        targetTurn: turn.turn,
-        targetEventSeq: event.seq,
-        targetBlockIndex: operation.blockIndex,
-        blockKind: "user",
-        before: before.text,
-        after: operation.text,
-      }),
-      queuedUsers: [edited, ...later],
-    };
-  }
-
-  // 未闭合轮次的助手消息是流式 partial，无最终内容可编辑。
-  if (!turn.closed)
-    throw new SessionBranchError("未闭合轮次的助手消息不可编辑。", "INVALID_BOUNDARY");
-  const before = event.data.message.content[operation.blockIndex];
-  if (!isTextualBlock(before))
-    throw new SessionBranchError("所选助手消息块不是文本或思考。", "INVALID_BOUNDARY");
-  const blockKind: EditableBlockKind =
-    before.type === "reasoning" ? "assistant.reasoning" : "assistant.response";
-  if (turn.user === undefined)
-    throw new SessionBranchError("所选助手消息没有可重建的用户输入。", "INVALID_BOUNDARY");
-  return {
-    anchorSeq: turn.startSeq,
-    version: pairVersionEffect(operation.sessionId, {
-      operation: "edit",
-      cascade: operation.cascade,
-      targetTurn: turn.turn,
-      targetEventSeq: event.seq,
-      targetBlockIndex: operation.blockIndex,
-      blockKind,
-      before: before.text,
-      after: operation.text,
-    }),
-    manualTurn: {
-      turn: turn.turn,
-      user: cloneUser(turn.user.data),
-      assistant: assistantReplacement(event, operation.blockIndex, operation.text),
-    },
-    queuedUsers: operation.cascade === "preserve" ? downstreamUsers(turns, turnIndex + 1) : [],
-  };
-}
-
-function retryPlan(operation: RetryOperation, turns: readonly ClosedTurn[]): OperationPlan {
-  const turnIndex = turns.findIndex((turn) => turn.turn === operation.turn);
-  const turn = turns[turnIndex];
-  if (turn?.user === undefined)
-    throw new SessionBranchError("所选回合没有可重放的用户输入。", "INVALID_BOUNDARY");
-  return {
-    anchorSeq: turn.startSeq,
-    version: pairVersionEffect(operation.sessionId, {
-      operation: "retry",
-      cascade: operation.cascade,
-      targetTurn: turn.turn,
-      targetEventSeq: turn.user.seq,
-    }),
-    queuedUsers:
-      operation.cascade === "preserve"
-        ? downstreamUsers(turns, turnIndex)
-        : [cloneUser(turn.user.data)],
-  };
-}
-
-function rerollPlan(operation: RerollOperation, turns: readonly ClosedTurn[]): OperationPlan {
-  for (let index = turns.length - 1; index >= 0; index -= 1) {
-    const turn = turns[index];
-    // 未闭合轮次无已落定的助手回复可重生成。
-    if (turn?.user === undefined || !turn.closed) continue;
-    const target = turn.assistants.findLast((event) =>
-      event.data.message.content.some(isTextualBlock),
-    );
-    if (target === undefined) continue;
-    return {
-      anchorSeq: turn.startSeq,
-      version: pairVersionEffect(operation.sessionId, {
-        operation: "reroll",
-        cascade: "truncate",
-        targetTurn: turn.turn,
-        targetEventSeq: target.seq,
-      }),
-      queuedUsers: [cloneUser(turn.user.data)],
-    };
-  }
-  throw new SessionBranchError("当前会话没有可重生成的已落定助手回复。", "INVALID_BOUNDARY");
-}
-
 function appendLogSeedEvent(
   events: SessionEvent[],
   type: string,
@@ -429,10 +142,9 @@ function appendManualTurn(
   appendSurfaceSeedEvent(
     events,
     "assistant/message",
-    { turn, step: 1, message: assistant },
+    { turn, step: 1, message: assistant, stream: [] },
     {
       surfaceOp: "append",
-      sourceEventSeqs: [],
     },
   );
   appendLogSeedEvent(events, "step/end", { turn, step: 1 });
@@ -442,7 +154,11 @@ function appendManualTurn(
   });
 }
 
-function appendSeedSuffixLive(session: Session, seedSuffix: readonly SessionEvent[]): void {
+async function appendSeedSuffixLive(
+  session: Session,
+  seedSuffix: readonly SessionEvent[],
+  appendDirect: (events: readonly SessionEvent[]) => Promise<void>,
+): Promise<void> {
   for (const event of seedSuffix) {
     // 版本效果事件携带 ignorable 标记（上游类型无此字段，duck-type 读取）。
     const ignorable = (event as { ignorable?: boolean }).ignorable === true;
@@ -451,10 +167,13 @@ function appendSeedSuffixLive(session: Session, seedSuffix: readonly SessionEven
         log: SessionEvent[];
         eventsSnapshot?: unknown;
       };
-      // ignorable 语义：live log 保留、不落 canonical log。session.append 不
-      // 保留 ignorable 标记，因此直接 push 内存 log（不发布）；seq 按 log
-      // 续接重编号（seedSuffix 内部编号从 0 起）。
-      s.log.push({ ...event, seq: s.log.length } as SessionEvent);
+      // 原样存储语义：版本效果事件经 RDB write handle 直接落库（带
+      // ignorable 信封，与 JSONL 一致）。session.append 不保留 ignorable
+      // 标记且类型系统禁止 append 未知类型，因此不发布、直接 push 内存
+      // log（seq 按 log 续接重编号，与 handle cursor 同空间）。
+      const seq = s.log.length;
+      await appendDirect([{ ...event, seq } as SessionEvent]);
+      s.log.push({ ...event, seq } as SessionEvent);
       s.eventsSnapshot = undefined;
       continue;
     }
@@ -574,8 +293,16 @@ export class SessionEditor extends Service {
     appendLogSeedEvent(seedSuffix, "session-branch/version", plan.version, true);
     if (plan.manualTurn !== undefined) appendManualTurn(seedSuffix, plan.manualTurn);
 
-    // 就地编辑：不创建新会话、不改变 id。先 rewind 截断到目标轮之前的闭合
-    // 边界，再 append 版本效果与重放输入，最后（可选）驱动 agent 重放。
+    // 就地编辑：不创建新会话、不改变 id。需要重放排队输入时，先在 rewind
+    // 前确保 agent 就绪（live agent 等其停；cold 先 resume）——rewind 截断后
+    // agent 无法再以完整会话 resume，且重放失败不应让截断静默丢弃内容。
+    const replay = await this.prepareReplay(
+      operation.sessionId,
+      plan.queuedUsers,
+      signal,
+      headerConfig,
+    );
+
     const turnIndex = turns.findIndex((turn) => turn.startSeq === plan.anchorSeq);
     const boundary =
       plan.rewindBoundary !== undefined
@@ -587,10 +314,25 @@ export class SessionEditor extends Service {
     await this.ctx.sessionBranch.rewind(operation.sessionId, boundary, signal);
     if (seedSuffix.length > 0) {
       if (live !== undefined) {
-        // live：版本效果 push 内存 log（ignorable 保留）、manualTurn 走 append，
-        // 同步 cursor 后显式 flush（push 不发布、不进缓冲，cursor 会落后）。
-        appendSeedSuffixLive(live, seedSuffix);
-        this.ctx.sessionBranch.syncLiveCursor(operation.sessionId);
+        // live：版本效果经 RDB write handle 直接落库（带 ignorable 信封，
+        // 与 JSONL 一致）、manualTurn 走 append；同步 cursor 后显式 flush
+        // （直接落库不发布、不进缓冲，cursor 会落后）。
+        const persistence = this.ctx.sessionPersistence as unknown as {
+          tracker: {
+            writerOf(id: SessionId):
+              | {
+                  append(events: readonly SessionEvent[]): Promise<void>;
+                }
+              | undefined;
+          };
+        };
+        const handle = persistence.tracker.writerOf(operation.sessionId);
+        if (handle === undefined) {
+          throw new Error(
+            `session "${operation.sessionId}" has no live write handle for the version effect`,
+          );
+        }
+        await appendSeedSuffixLive(live, seedSuffix, (events) => handle.append(events));
         await this.ctx.sessions.flush(live);
       } else {
         // cold：续写 seq 从平衡后的保留前缀接续（exclusive 截断可能残留
@@ -604,22 +346,28 @@ export class SessionEditor extends Service {
               seq: keepLength + index,
             }) as SessionEvent,
         );
-        await this.ctx.sessionPersistence.append(operation.sessionId, renumbered);
+        const handle = await this.ctx.sessionPersistence.open(operation.sessionId, "write");
+        try {
+          await handle.append(renumbered);
+        } finally {
+          await handle.close();
+        }
       }
     }
 
-    // 可选增强：agent 驱动（重放排队用户输入）。缺失 agents 服务时退化为
-    // 已 durable 的就地版本。
-    const queuedTurns = await this.driveAgent(
-      operation.sessionId,
-      plan.queuedUsers,
-      signal,
-      headerConfig,
-    );
+    // 发起新的 user prompt：把排队输入交给就绪的 agent（rewind 后其 session
+    // 已被截断，followup 基于截断后历史开新轮重放）。无 agent（agents 服务
+    // 缺失）时退化为已 durable 的就地版本。
+    let queuedTurns = 0;
+    if (replay.agent !== undefined && plan.queuedUsers.length > 0) {
+      for (const message of plan.queuedUsers) replay.agent.followup(message);
+      await this.ctx.sessions.flush(replay.agent.session);
+      queuedTurns = plan.queuedUsers.length;
+    }
     return {
       sessionId: operation.sessionId,
       queuedTurns,
-      // 操作后是否仍有 live owner（driveAgent 可能 resume 出 agent）。
+      // 操作后是否仍有 live owner（prepareReplay 可能 resume 出 agent）。
       live: this.ctx.sessions.get(operation.sessionId) !== undefined,
     };
   }
@@ -641,16 +389,34 @@ export class SessionEditor extends Service {
     return (await branch.readRawEvents(sessionId, signal)).events;
   }
 
-  private async driveAgent(
+  /**
+   * rewind 前确保 agent 可驱动重放：live agent 先等待其停下（rewind 会截断其
+   * session 内存 log，须在 quiescence 后执行）；cold 会话先 resume 出驻留
+   * agent（此时会话完整，resume 的 prepare 不与截断冲突）。agents 服务缺失或
+   * 无需重放时返回空——调用方退化为就地截断版本。
+   */
+  private async prepareReplay(
     sessionId: SessionId,
     queuedUsers: readonly UserMessage[],
-    signal?: AbortSignal,
+    signal: AbortSignal | undefined,
     headerConfig?: { provider?: string; model?: string; maxTokens?: number },
-  ): Promise<number> {
-    if (queuedUsers.length === 0) return 0;
+  ): Promise<{ agent: EditorAgent | undefined }> {
+    if (queuedUsers.length === 0) return { agent: undefined };
     signal?.throwIfAborted();
     const agents = this.ctx.get("agents") as EditorAgentRegistry | undefined;
-    if (agents === undefined) return 0;
+    if (agents === undefined) return { agent: undefined };
+    const existing = agents.get(sessionId);
+    if (existing !== undefined) {
+      await existing.whenIdle();
+      signal?.throwIfAborted();
+      // 清空 inbox 残留（rewind 将删除这些输入所属轮次的事件；残留消息若
+      // 不清空，agent 后续 splice 落库后无法从日志重放——inbox 增量投影
+      // 假设 log 只 append）。
+      if (existing.inboxPending) existing.clearInbox();
+      return { agent: existing };
+    }
+    // cold：resume 已持久化会话（create 会因「已存在持久化日志」失败）。
+    // resume 失败是硬错误：rewind 尚未发生，编辑保持原子（不截断不丢数据）。
     const provider = headerConfig?.provider ?? "";
     const model = headerConfig?.model ?? "";
     if (provider.length === 0 || model.length === 0) {
@@ -660,51 +426,22 @@ export class SessionEditor extends Service {
         .config;
       const fallbackProvider = config?.provider ?? "";
       const fallbackModel = config?.model ?? "";
-      if (fallbackProvider.length === 0 || fallbackModel.length === 0) return 0;
-      return this.queueThroughAgent(
-        sessionId,
-        queuedUsers,
-        signal,
-        fallbackProvider,
-        fallbackModel,
-      );
-    }
-    return this.queueThroughAgent(sessionId, queuedUsers, signal, provider, model);
-  }
-
-  private async queueThroughAgent(
-    sessionId: SessionId,
-    queuedUsers: readonly UserMessage[],
-    signal: AbortSignal | undefined,
-    provider: string,
-    model: string,
-  ): Promise<number> {
-    const agents = this.ctx.get("agents") as EditorAgentRegistry | undefined;
-    if (agents === undefined) return 0;
-    // 现有 live agent：直接排队输入（其 session 内存已被 rewind 截断，
-    // followup 基于截断后历史重放，不改 id、不重建）。
-    const existing = agents.get(sessionId);
-    if (existing !== undefined) {
-      for (const message of queuedUsers) existing.followup(message);
-      await this.ctx.sessions.flush(existing.session);
-      return queuedUsers.length;
-    }
-    // cold：resume 已持久化会话（create 会因「已存在持久化日志」失败）。
-    // resume 后 agent 驻留，不 dispose（dispose 会破坏客户端打开的窗口）。
-    const handle = await agents
-      .resume({ resumeSessionId: sessionId, agentOptions: { provider, model } })
-      .catch((error: unknown) => {
-        // agent 组合失败不应使已 durable 的版本失效：退化为持久化版本。
-        this.ctx.logger.warn(
-          "session-editor: agent resume failed (%s); version remains durable",
-          String(error),
-        );
-        return undefined;
+      if (fallbackProvider.length === 0 || fallbackModel.length === 0) {
+        throw new SessionBranchError("无法重放：会话没有可解析的模型配置。", "INVALID_BOUNDARY");
+      }
+      const handle = await agents.resume({
+        resumeSessionId: sessionId,
+        agentOptions: { provider: fallbackProvider, model: fallbackModel },
       });
-    if (handle === undefined) return 0;
-    for (const message of queuedUsers) handle.agent.followup(message);
-    await this.ctx.sessions.flush(handle.agent.session);
-    return queuedUsers.length;
+      signal?.throwIfAborted();
+      return { agent: handle.agent };
+    }
+    const handle = await agents.resume({
+      resumeSessionId: sessionId,
+      agentOptions: { provider, model },
+    });
+    signal?.throwIfAborted();
+    return { agent: handle.agent };
   }
 }