@morlay/ui-conversation-message-actions 0.0.18 → 0.0.19-alpha.1

package/src/plan.ts

@@ -1,5 +1,6 @@
 import { randomUUID } from "node:crypto";
 import type { AssistantMessage, ContentBlock, UserMessage } from "@deepseek-ai/dsh-llm";
+import { SessionSeq } from "@deepseek-ai/dsh-session";
 import type { SessionEvent, SessionId } from "@deepseek-ai/dsh-session";
 import {
   SESSION_BRANCH_VERSION_SCHEMA,
@@ -24,7 +25,7 @@ export interface ClosedTurn {
 
   closed: boolean;
   user?: SessionEvent<"user/message">;
-  /** 轮内全部 user/message（agent 运行中 followup 追加的输入也计入）。 */
+
   users: SessionEvent<"user/message">[];
   assistants: SessionEvent<"assistant/message">[];
 }
@@ -38,6 +39,9 @@ export interface OperationPlan {
   manualTurn?: { turn: number; user: UserMessage; assistant: AssistantMessage };
 
   queuedUsers: UserMessage[];
+
+  // 操作目标事件（被重放或撤回的那条）的 seq
+  targetSeq: number;
 }
 
 function isTextualBlock(
@@ -88,8 +92,6 @@ export function closedTurns(events: readonly SessionEvent[]): ClosedTurn[] {
     }
     if (current === undefined) continue;
     if (event.type === "user/message" && event.data.source.kind === "user") {
-      // 轮内全部 user/message 都记录：agent 运行中 followup 追加的输入
-      // （第二条及之后）也是已落定文本，可编辑。
       if (current.user === undefined) current.user = event;
       current.users.push(event);
       continue;
@@ -103,8 +105,7 @@ export function closedTurns(events: readonly SessionEvent[]): ClosedTurn[] {
       current = undefined;
     }
   }
-  // 未闭合轮次（无 turn/end）也保留：user 消息已落定，编辑时 rewind 到该
-  // 消息（exclusive drop）重放即可。
+
   if (current !== undefined) result.push({ ...current, closed: false });
   return result;
 }
@@ -126,7 +127,7 @@ export function editableMessages(turns: readonly ClosedTurn[]): EditableMessageB
         });
       }
     }
-    // 未闭合轮次的助手消息是流式 partial，不可编辑。
+
     if (!turn.closed) continue;
     for (const event of turn.assistants) {
       for (const [blockIndex, block] of event.data.message.content.entries()) {
@@ -148,7 +149,6 @@ export function editableMessages(turns: readonly ClosedTurn[]): EditableMessageB
 
 export function retryableTurns(turns: readonly ClosedTurn[]): RetryableTurn[] {
   return turns.flatMap((turn): RetryableTurn[] =>
-    // 未闭合轮次无已落定回复可重生成，不可重试。
     turn.user === undefined || !turn.closed
       ? []
       : [
@@ -162,12 +162,6 @@ export function retryableTurns(turns: readonly ClosedTurn[]): RetryableTurn[] {
   );
 }
 
-/**
- * 目标轮之前最后一个「有内容」轮次的下标：跳过既无用户输入也无助手回复的
- * 空轮。空轮是早期重放缺陷的遗留（turn/start 后直接 turn/end），在轨迹 /
- * 轮次导航里表现为点不开的空项，并让后续轮号出现空洞。rewind 把它们随
- * 目标轮一起截断，重放按保留前缀续号即可自愈。
- */
 export function precedingContentIndex(turns: readonly ClosedTurn[], turnIndex: number): number {
   let index = turnIndex - 1;
   while (index >= 0) {
@@ -184,9 +178,6 @@ export function downstreamUsers(turns: readonly ClosedTurn[], start: number): Us
     .flatMap((turn): UserMessage[] => turn.users.map((user) => cloneUser(user.data)));
 }
 
-// 撤回的 rewind 边界：轮内消息沿用 edit 的轮首规则（轮首整轮截断到前一轮
-// turn/end，无前轮则 -1；轮内 followup 截断到该消息本身），轮外 user 消息按
-// 消息自身位置 exclusive drop（截断该消息及其后全部）。
 export function recallBoundary(
   events: readonly SessionEvent[],
   turns: readonly ClosedTurn[],
@@ -263,17 +254,13 @@ export function editPlan(operation: EditOperation, turns: readonly ClosedTurn[])
       event.data,
       replaceTextBlock(event.data.content, operation.blockIndex, operation.text),
     );
-    // 轮内后续 user/message（agent 运行中 followup 追加的输入）是已落定
-    // 输入：rewind 会 drop 它们，重放时保留（truncate 只截断回复，不丢输入）。
+
     const userIndex = turn.users.findIndex((candidate) => candidate.seq === event.seq);
     const sameTurnFollowups = turn.users.slice(userIndex + 1).map((user) => cloneUser(user.data));
     const later = operation.cascade === "preserve" ? downstreamUsers(turns, turnIndex + 1) : [];
     return {
       anchorSeq: turn.startSeq,
-      // 轮首 user 编辑：整轮截断重放（rewind 到前一轮 turn/end），重放复用
-      // 目标轮号；未闭合轮同样整轮截断——保留悬空的 turn/start 会让重放
-      // 开到下一轮，轮号对不上。轮内 followup 只 rewind 到该消息本身
-      // （exclusive drop），保留轮内已落定的前置输入与回复。
+
       ...(userIndex === 0 ? {} : { rewindBoundary: event.seq }),
       version: pairVersionEffect(operation.sessionId, {
         operation: "edit",
@@ -286,10 +273,10 @@ export function editPlan(operation: EditOperation, turns: readonly ClosedTurn[])
         after: operation.text,
       }),
       queuedUsers: [edited, ...sameTurnFollowups, ...later],
+      targetSeq: event.seq,
     };
   }
 
-  // 未闭合轮次的助手消息是流式 partial，无最终内容可编辑。
   if (!turn.closed)
     throw new SessionBranchError("未闭合轮次的助手消息不可编辑。", "INVALID_BOUNDARY");
   const before = event.data.message.content[operation.blockIndex];
@@ -317,6 +304,7 @@ export function editPlan(operation: EditOperation, turns: readonly ClosedTurn[])
       assistant: assistantReplacement(event, operation.blockIndex, operation.text),
     },
     queuedUsers: operation.cascade === "preserve" ? downstreamUsers(turns, turnIndex + 1) : [],
+    targetSeq: event.seq,
   };
 }
 
@@ -337,6 +325,7 @@ export function retryPlan(operation: RetryOperation, turns: readonly ClosedTurn[
       operation.cascade === "preserve"
         ? downstreamUsers(turns, turnIndex)
         : turn.users.map((user) => cloneUser(user.data)),
+    targetSeq: turn.user.seq,
   };
 }
 
@@ -346,7 +335,7 @@ export function rerollPlan(
 ): 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),
@@ -361,7 +350,183 @@ export function rerollPlan(
         targetEventSeq: target.seq,
       }),
       queuedUsers: turn.users.map((user) => cloneUser(user.data)),
+      targetSeq: target.seq,
     };
   }
   throw new SessionBranchError("当前会话没有可重生成的已落定助手回复。", "INVALID_BOUNDARY");
 }
+
+export interface CompactionBracket {
+  start: SessionEvent;
+  summary?: SessionEvent;
+  checkpoint: SessionEvent;
+  end: SessionEvent;
+}
+
+const COMPACTION_TYPES: ReadonlySet<string> = new Set([
+  "compaction/start",
+  "compaction/summary",
+  "compaction/end",
+]);
+
+// 本包不加载 compaction 的事件类型增强，按类型字符串与结构性字段读取（与 session-rdb 的 schema、log 同一处理方式）。
+function compactionTypeOf(event: SessionEvent): string | undefined {
+  return COMPACTION_TYPES.has(event.type) ? event.type : undefined;
+}
+
+// 压缩事务的替换消息：compact 插件写入的 surface replace 用户消息（checkpoint）。
+function isCompactionCheckpoint(event: SessionEvent): boolean {
+  if (event.type !== "user/message") return false;
+  const op = (event as unknown as { surfaceOp?: unknown }).surfaceOp;
+  if (typeof op !== "object" || op === null) return false;
+  const source = event.data.source as unknown as { kind?: unknown; plugin?: unknown };
+  return source.kind === "plugin" && source.plugin === "compact";
+}
+
+function compactionBrackets(events: readonly SessionEvent[]): CompactionBracket[] {
+  const brackets: CompactionBracket[] = [];
+  let open: { start: SessionEvent; summary?: SessionEvent; checkpoint?: SessionEvent } | undefined;
+  for (const event of events) {
+    const type = compactionTypeOf(event);
+    if (type === "compaction/start") {
+      open = { start: event };
+      continue;
+    }
+    if (open === undefined) continue;
+    if (type === "compaction/summary") {
+      open.summary = event;
+      continue;
+    }
+    if (type === "compaction/end") {
+      if (open.checkpoint !== undefined) {
+        brackets.push({
+          start: open.start,
+          ...(open.summary === undefined ? {} : { summary: open.summary }),
+          checkpoint: open.checkpoint,
+          end: event,
+        });
+      }
+      open = undefined;
+      continue;
+    }
+    if (isCompactionCheckpoint(event)) open.checkpoint = event;
+  }
+  return brackets;
+}
+
+// 截断丢掉、但仍在重放目标之前的完整压缩事务。
+export function droppedCompactions(
+  events: readonly SessionEvent[],
+  keepFrom: number,
+  targetSeq: number,
+): CompactionBracket[] {
+  return compactionBrackets(events).filter(
+    (bracket) => bracket.start.seq >= keepFrom && bracket.end.seq < targetSeq,
+  );
+}
+
+function replacementRange(event: SessionEvent): { start: number; end: number } | undefined {
+  const op = (
+    event as unknown as { surfaceOp?: { op?: unknown; startSeq?: unknown; endSeq?: unknown } }
+  ).surfaceOp;
+  if (op?.op !== "replace") return undefined;
+  if (typeof op.startSeq !== "number" || typeof op.endSeq !== "number") return undefined;
+  return { start: op.startSeq, end: op.endSeq };
+}
+
+function numberList(value: unknown): number[] {
+  return Array.isArray(value)
+    ? value.filter((item): item is number => typeof item === "number")
+    : [];
+}
+
+// 把截断丢掉的压缩重排到 base 起的连续 seq：standalone 形态（不属于任何 turn，与手动 /compact 一致），
+// 摘要替换引用的 seq 同步重编号（保留前缀内的 seq 不变），metering 事件与替换消息保持相邻。
+export function restoreCompactions(
+  brackets: readonly CompactionBracket[],
+  keepFrom: number,
+  base: number,
+): SessionEvent[] {
+  const moved = new Map<number, number>();
+  const resolve = (seq: number): number | undefined => (seq < keepFrom ? seq : moved.get(seq));
+  const resolveAll = (seqs: readonly number[]): number[] | undefined => {
+    const resolved: number[] = [];
+    for (const seq of seqs) {
+      const next = resolve(seq);
+      if (next === undefined) return undefined;
+      resolved.push(next);
+    }
+    return resolved;
+  };
+
+  const restored: SessionEvent[] = [];
+  for (const bracket of brackets) {
+    const range = replacementRange(bracket.checkpoint);
+    const shadowedSeqs = resolveAll(
+      numberList((bracket.summary?.data as { shadowedSeqs?: unknown } | undefined)?.shadowedSeqs),
+    );
+    const start = range === undefined ? undefined : resolve(range.start);
+    const end = range === undefined ? undefined : resolve(range.end);
+    // 引用了被丢弃事件的压缩无法重建替换范围，只能一并丢弃
+    if (start === undefined || end === undefined || shadowedSeqs === undefined) continue;
+
+    const at = base + restored.length;
+    const summary = bracket.summary;
+    const checkpointSeq = at + (summary === undefined ? 1 : 2);
+    moved.set(bracket.start.seq, at);
+    if (summary !== undefined) moved.set(summary.seq, at + 1);
+    moved.set(bracket.checkpoint.seq, checkpointSeq);
+    moved.set(bracket.end.seq, checkpointSeq + 1);
+
+    // 引用自身事务的事件按新位置重算：开标记、metering 事件、替换范围内的 surface 节点
+    const sources = [at, ...(summary === undefined ? [] : [at + 1]), ...shadowedSeqs];
+    restored.push(
+      standaloneCompaction(bracket.start, at),
+      ...(summary === undefined
+        ? []
+        : [meteringShadowPrice(summary, at + 1, { start, end }, shadowedSeqs)]),
+      replacementCheckpoint(bracket.checkpoint, checkpointSeq, { start, end }, sources),
+      standaloneCompaction(bracket.end, checkpointSeq + 1),
+    );
+  }
+  return restored;
+}
+
+function standaloneCompaction(event: SessionEvent, seq: number): SessionEvent {
+  return {
+    ...event,
+    seq: SessionSeq(seq),
+    data: { ...event.data, turn: null },
+  } as unknown as SessionEvent;
+}
+
+function meteringShadowPrice(
+  event: SessionEvent,
+  seq: number,
+  range: { start: number; end: number },
+  shadowedSeqs: readonly number[],
+): SessionEvent {
+  return {
+    ...event,
+    seq: SessionSeq(seq),
+    data: {
+      ...event.data,
+      shadowedRange: { start: range.start, end: range.end },
+      shadowedSeqs: [...shadowedSeqs],
+    },
+  } as unknown as SessionEvent;
+}
+
+function replacementCheckpoint(
+  event: SessionEvent,
+  seq: number,
+  range: { start: number; end: number },
+  sources: readonly number[],
+): SessionEvent {
+  return {
+    ...event,
+    seq: SessionSeq(seq),
+    surfaceOp: { op: "replace", startSeq: range.start, endSeq: range.end },
+    sourceEventSeqs: [...sources],
+  } as unknown as SessionEvent;
+}

package/src/shared.ts

@@ -63,7 +63,7 @@ export interface SessionEditorOperationResult {
 
 export interface EditableMessageBlock {
   key: string;
-  // 消息所属轮号；轮外消息（无 turn 归属）缺省。
+
   turn?: number;
   eventSeq: number;
   blockIndex: number;

package/src/testing.ts

@@ -43,8 +43,7 @@ export async function harness(provide?: (ctx: Context) => void): Promise<Harness
   await ctx.plugin(SessionStore);
   new SessionProjectionRegistry(ctx);
   const fiber = await ctx.plugin(SessionPersistenceSqlite, { type: "sqlite", path: ":memory:" });
-  // 额外服务（如 HTTP 面测试的 webServer 替身）必须在 SessionEditor 构造前
-  // 就绪：构造函数内的 effect 只在服务可解析时注册路由。
+
   provide?.(ctx);
   await ctx.plugin(SessionEditor);
   return { ctx, editor: ctx.sessionEditor, dispose: () => fiber.dispose() };
@@ -78,7 +77,6 @@ export async function createPersisted(
   }
 }
 
-/** 构造一条 user/message 事件。 */
 export function userMessage(seq: number, id: string, text: string, time = seq): SessionEvent {
   return {
     type: "user/message",
@@ -94,7 +92,6 @@ export function userMessage(seq: number, id: string, text: string, time = seq):
   } as SessionEvent;
 }
 
-/** 构造一条 assistant/message 事件（纯文本回复）。 */
 export function assistantMessage(
   seq: number,
   turn: number,
@@ -122,7 +119,6 @@ export function assistantMessage(
   } as unknown as SessionEvent;
 }
 
-/** 真实 agent-loop 形状的一轮：轮首输入 + 可选 followup，可闭合。 */
 export function turnLog(
   base: number,
   turn: number,

package/src/types.ts

@@ -65,7 +65,7 @@ export type SessionEditorTimeline = BranchTimeline;
 
 export interface EditableMessageBlock {
   key: string;
-  // 消息所属轮号；轮外消息（无 turn 归属）缺省。
+
   turn?: number;
   eventSeq: number;
   blockIndex: number;