@morlay/ui-conversation-message-actions 0.0.11 → 0.0.13

package/src/plan.ts

@@ -0,0 +1,322 @@
+import { randomUUID } from "node:crypto";
+import type { AssistantMessage, ContentBlock, UserMessage } from "@deepseek-ai/dsh-llm";
+import type { SessionEvent, SessionId } from "@deepseek-ai/dsh-session";
+import {
+  SESSION_BRANCH_VERSION_SCHEMA,
+  SessionBranchError,
+  type EditableBlockKind,
+  type SessionBranchEffect,
+  type SessionBranchVersionEvent,
+} from "@morlay/session-branch";
+import type {
+  EditOperation,
+  EditableMessageBlock,
+  RerollOperation,
+  RetryOperation,
+  RetryableTurn,
+} from "./types.ts";
+
+export interface ClosedTurn {
+  turn: number;
+  startSeq: number;
+
+  endSeq?: number;
+
+  closed: boolean;
+  user?: SessionEvent<"user/message">;
+  /** 轮内全部 user/message（agent 运行中 followup 追加的输入也计入）。 */
+  users: SessionEvent<"user/message">[];
+  assistants: SessionEvent<"assistant/message">[];
+}
+
+export interface OperationPlan {
+  anchorSeq: number;
+
+  rewindBoundary?: number;
+  version: SessionBranchVersionEvent;
+
+  manualTurn?: { turn: number; user: UserMessage; assistant: AssistantMessage };
+
+  queuedUsers: UserMessage[];
+}
+
+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),
+  );
+}
+
+export 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, users: [], assistants: [] };
+      continue;
+    }
+    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;
+    }
+    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;
+}
+
+export function editableMessages(turns: readonly ClosedTurn[]): EditableMessageBlock[] {
+  const result: EditableMessageBlock[] = [];
+  for (const turn of turns) {
+    for (const user of turn.users) {
+      for (const [blockIndex, block] of user.data.content.entries()) {
+        if (block.type !== "text") continue;
+        result.push({
+          key: `${String(user.seq)}:${String(blockIndex)}`,
+          turn: turn.turn,
+          eventSeq: user.seq,
+          blockIndex,
+          kind: "user",
+          text: block.text,
+          time: 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;
+}
+
+export 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,
+          },
+        ],
+  );
+}
+
+export function downstreamUsers(turns: readonly ClosedTurn[], start: number): UserMessage[] {
+  return turns
+    .slice(start)
+    .flatMap((turn): UserMessage[] => turn.users.map((user) => cloneUser(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;
+}
+
+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 },
+  };
+}
+
+export 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.users.find((candidate) => candidate.seq === operation.eventSeq) ??
+    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),
+    );
+    // 轮内后续 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）；
+      // 其余情况（未闭合轮、轮内 followup）：rewind 到该消息本身
+      // （exclusive drop），保留轮内已落定的前置输入与回复。
+      ...(turn.closed && userIndex === 0 ? {} : { 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, ...sameTurnFollowups, ...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) : [],
+  };
+}
+
+export 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)
+        : turn.users.map((user) => cloneUser(user.data)),
+  };
+}
+
+export 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: turn.users.map((user) => cloneUser(user.data)),
+    };
+  }
+  throw new SessionBranchError("当前会话没有可重生成的已落定助手回复。", "INVALID_BOUNDARY");
+}

package/src/shared.ts

@@ -0,0 +1,167 @@
+import type { SessionId } from "@deepseek-ai/dsh-session";
+import type { BranchTimeline, CascadePolicy } from "@morlay/session-branch";
+import type { VersionOperation } from "@morlay/session-branch";
+
+export const SESSION_EDITOR_PATH = "/session-editor";
+
+export type { VersionOperation } from "@morlay/session-branch";
+
+export interface EditOperation {
+  action: "edit";
+  sessionId: SessionId;
+  eventSeq: number;
+  blockIndex: number;
+  text: string;
+  cascade: CascadePolicy;
+}
+
+export interface RerollOperation {
+  action: "reroll";
+  sessionId: SessionId;
+}
+
+export interface RetryOperation {
+  action: "retry";
+  sessionId: SessionId;
+  turn: number;
+  cascade: CascadePolicy;
+}
+
+export interface RewindOperation {
+  action: "rewind";
+  sessionId: SessionId;
+  toBoundary: number;
+}
+
+export interface ForkOperation {
+  action: "fork";
+  sessionId: SessionId;
+  atSeq?: number;
+  childSessionId?: SessionId;
+}
+
+export type SessionEditorOperation =
+  | EditOperation
+  | RerollOperation
+  | RetryOperation
+  | RewindOperation
+  | ForkOperation;
+
+export interface SessionEditorOperationResult {
+  sessionId: SessionId;
+  queuedTurns: number;
+
+  live?: boolean;
+}
+
+export interface EditableMessageBlock {
+  key: string;
+  turn: number;
+  eventSeq: number;
+  blockIndex: number;
+  kind: "user" | "assistant.reasoning" | "assistant.response";
+  text: string;
+  time: number;
+}
+
+export interface RetryableTurn {
+  turn: number;
+  userEventSeq: number;
+  preview: string;
+  time: number;
+}
+
+export interface VersionSummary {
+  sessionId: string;
+  parentSessionId?: string;
+  effectId?: string;
+  inverseSessionId?: string;
+  createdAt: number;
+  depth: number;
+  current: boolean;
+  onCurrentEffectPath: boolean;
+  operation?: VersionOperation;
+  cascade?: CascadePolicy;
+  targetTurn?: number;
+  blockKind?: EditableMessageBlock["kind"];
+  before?: string;
+  after?: string;
+}
+
+export interface SessionEditorTimeline {
+  sessionId: string;
+  messages: EditableMessageBlock[];
+  retryableTurns: RetryableTurn[];
+  versions: VersionSummary[];
+
+  undoStack: string[];
+
+  redoSessionIds: string[];
+}
+
+export function toTimelinePayload(
+  sessionId: SessionId,
+  timeline: BranchTimeline,
+  messages: EditableMessageBlock[],
+  retryableTurns: RetryableTurn[],
+): SessionEditorTimeline {
+  const currentPath = new Set<string>();
+  for (const node of timeline.nodes) currentPath.add(String(node.sessionId));
+  const versions: VersionSummary[] = timeline.nodes.map((node) => ({
+    sessionId: String(node.sessionId),
+    ...(node.parentSessionId === undefined
+      ? {}
+      : { parentSessionId: String(node.parentSessionId) }),
+    ...(node.effect === undefined
+      ? {}
+      : {
+          effectId: node.effect.id,
+          inverseSessionId: String(node.inverseSessionId),
+          operation: node.effect.operation,
+          cascade: node.effect.cascade,
+          targetTurn: node.effect.targetTurn,
+          ...(node.effect.blockKind === undefined ? {} : { blockKind: node.effect.blockKind }),
+          ...(node.effect.before === undefined ? {} : { before: node.effect.before }),
+          ...(node.effect.after === undefined ? {} : { after: node.effect.after }),
+        }),
+    createdAt: node.createdAt,
+    depth: depthOf(timeline, node.sessionId),
+    current: String(node.sessionId) === String(sessionId),
+    onCurrentEffectPath: currentPath.has(String(node.sessionId)),
+  }));
+  const versionsById = new Map(versions.map((version) => [version.sessionId, version]));
+  const undoStack: string[] = [];
+  let cursor = versionsById.get(String(sessionId));
+  while (cursor?.inverseSessionId !== undefined) {
+    if (undoStack.includes(cursor.inverseSessionId)) break;
+    undoStack.push(cursor.inverseSessionId);
+    cursor = versionsById.get(cursor.inverseSessionId);
+  }
+  const redoSessionIds = versions
+    .filter((version) => version.inverseSessionId === String(sessionId))
+    .map((version) => version.sessionId);
+  return {
+    sessionId: String(sessionId),
+    messages,
+    retryableTurns,
+    versions,
+    undoStack,
+    redoSessionIds,
+  };
+}
+
+function depthOf(
+  timeline: BranchTimeline,
+  sessionId: import("@deepseek-ai/dsh-session").SessionId,
+): number {
+  const byId = new Map(timeline.nodes.map((node) => [String(node.sessionId), node]));
+  let depth = 0;
+  let cursor = byId.get(String(sessionId));
+  const seen = new Set<string>();
+  while (cursor?.parentSessionId !== undefined && !seen.has(String(cursor.sessionId))) {
+    seen.add(String(cursor.sessionId));
+    depth += 1;
+    cursor = byId.get(String(cursor.parentSessionId));
+  }
+  return depth;
+}

package/src/testing.ts

@@ -0,0 +1,151 @@
+import { Context } from "@deepseek-ai/cordis";
+import { TokenMeter } from "@deepseek-ai/dsh-token-meter";
+import {
+  Session,
+  SessionId as SessionIdBrand,
+  SessionSeq,
+  SessionStore,
+  type SessionEvent,
+  type SessionHeader,
+} from "@deepseek-ai/dsh-session";
+import SessionProjectionRegistry from "@deepseek-ai/dsh-session-projection";
+import { type BranchTimeline } from "@morlay/session-branch";
+import SessionPersistenceSqlite from "@morlay/session-rdb";
+import { parseJsonlArtifact } from "@morlay/session-rdb/artifact";
+import { EmptySettings, meta, oneTurnLog } from "@morlay/session-rdb/testing";
+import { SessionEditor } from "@morlay/ui-conversation-message-actions";
+
+export {
+  BranchTimeline,
+  Session,
+  SessionIdBrand,
+  SessionSeq,
+  SessionStore,
+  TokenMeter,
+  EmptySettings,
+  meta,
+  oneTurnLog,
+  parseJsonlArtifact,
+};
+export type { SessionEvent, SessionHeader };
+
+export interface Harness {
+  ctx: Context;
+  editor: SessionEditor;
+  dispose: () => Promise<void>;
+}
+
+export async function harness(): Promise<Harness> {
+  const ctx = new Context();
+  await ctx.plugin(EmptySettings);
+  await ctx.plugin(SessionStore);
+  new SessionProjectionRegistry(ctx);
+  const fiber = await ctx.plugin(SessionPersistenceSqlite, { type: "sqlite", path: ":memory:" });
+  await ctx.plugin(SessionEditor);
+  return { ctx, editor: ctx.sessionEditor, dispose: () => fiber.dispose() };
+}
+
+export function twoTurnLog(): SessionEvent[] {
+  const first = oneTurnLog();
+  const second: SessionEvent[] = oneTurnLog().map(
+    (event) =>
+      ({
+        ...event,
+        seq: event.seq + 6,
+        time: event.time + 100,
+        data: { ...event.data, turn: 2 },
+      }) as SessionEvent,
+  );
+  return [...first, ...second];
+}
+
+export async function createPersisted(
+  ctx: Context,
+  id: string,
+  events: readonly SessionEvent[],
+  header: SessionHeader = meta(id),
+): Promise<void> {
+  await ctx.sessionPersistence.create(header);
+  await ctx.sessionPersistence.append(SessionIdBrand(id), [...events]);
+}
+
+/** 构造一条 user/message 事件。 */
+export function userMessage(
+  seq: number,
+  id: string,
+  text: string,
+  time = seq,
+): SessionEvent {
+  return {
+    type: "user/message",
+    seq: SessionSeq(seq),
+    time,
+    data: {
+      id,
+      role: "user",
+      content: [{ type: "text", text }],
+      source: { kind: "user" },
+    },
+    surfaceOp: "append",
+  } as SessionEvent;
+}
+
+/** 构造一条 assistant/message 事件（纯文本回复）。 */
+export function assistantMessage(
+  seq: number,
+  turn: number,
+  step: number,
+  id: string,
+  text: string,
+  time = seq,
+): SessionEvent {
+  return {
+    type: "assistant/message",
+    seq: SessionSeq(seq),
+    time,
+    data: {
+      turn,
+      step,
+      message: {
+        id,
+        role: "assistant",
+        content: [{ type: "text", text }],
+        source: { kind: "model", provider: "mock", model: "mock" },
+      },
+    },
+    surfaceOp: "append",
+  } as SessionEvent;
+}
+
+/** 真实 agent-loop 形状的一轮：轮首输入 + 可选 followup，可闭合。 */
+export function turnLog(
+  base: number,
+  turn: number,
+  opts: { users?: Array<{ id: string; text: string }>; closed?: boolean; time?: number } = {},
+): SessionEvent[] {
+  const { closed = true, time = base } = opts;
+  const users = opts.users ?? [{ id: `t${turn}-u1`, text: `turn ${turn} input` }];
+  const events: SessionEvent[] = [
+    { type: "turn/start", seq: SessionSeq(base), time, data: { turn } },
+  ];
+  let seq = base + 1;
+  let step = 1;
+  for (const user of users) {
+    events.push({ type: "step/start", seq: SessionSeq(seq++), time, data: { turn, step } });
+    events.push(userMessage(seq++, user.id, user.text, time));
+    events.push(
+      assistantMessage(seq++, turn, step, `${user.id}-a`, `answer to ${user.text}`, time),
+    );
+    events.push({ type: "step/end", seq: SessionSeq(seq++), time, data: { turn, step } });
+    step += 1;
+  }
+  if (closed) {
+    events.push({
+      type: "turn/end",
+      seq: SessionSeq(seq++),
+      time,
+      data: { turn, reason: { kind: "completed" } },
+    });
+  }
+  return events;
+}

package/src/types.ts

@@ -0,0 +1,73 @@
+import type { SessionId } from "@deepseek-ai/dsh-session";
+import type { BranchTimeline, CascadePolicy } from "@morlay/session-branch";
+
+export interface EditOperation {
+  action: "edit";
+  sessionId: SessionId;
+
+  eventSeq: number;
+
+  blockIndex: number;
+
+  text: string;
+  cascade: CascadePolicy;
+}
+
+export interface RerollOperation {
+  action: "reroll";
+  sessionId: SessionId;
+}
+
+export interface RetryOperation {
+  action: "retry";
+  sessionId: SessionId;
+  turn: number;
+  cascade: CascadePolicy;
+}
+
+export interface RewindOperation {
+  action: "rewind";
+  sessionId: SessionId;
+  toBoundary: number;
+}
+
+export interface ForkOperation {
+  action: "fork";
+  sessionId: SessionId;
+  atSeq?: number;
+  childSessionId?: SessionId;
+}
+
+export type SessionEditorOperation =
+  | EditOperation
+  | RerollOperation
+  | RetryOperation
+  | RewindOperation
+  | ForkOperation;
+
+export interface SessionEditorResult {
+  sessionId: SessionId;
+
+  queuedTurns: number;
+
+  live?: boolean;
+}
+
+export type SessionEditorTimeline = BranchTimeline;
+
+export interface EditableMessageBlock {
+  key: string;
+  turn: number;
+  eventSeq: number;
+  blockIndex: number;
+  kind: "user" | "assistant.reasoning" | "assistant.response";
+  text: string;
+  time: number;
+}
+
+export interface RetryableTurn {
+  turn: number;
+  userEventSeq: number;
+  preview: string;
+  time: number;
+}