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

package/dist/plan-Cm9hCord.d.mts

@@ -0,0 +1,101 @@
+import { SessionEvent, SessionId } from "@deepseek-ai/dsh-session";
+import { BranchTimeline, CascadePolicy, SessionBranchVersionEvent } from "@morlay/session-branch";
+import { AssistantMessage, UserMessage } from "@deepseek-ai/dsh-llm";
+//#region src/types.d.ts
+interface EditOperation {
+  action: "edit";
+  sessionId: SessionId;
+  eventSeq: number;
+  blockIndex: number;
+  text: string;
+  cascade: CascadePolicy;
+}
+interface RerollOperation {
+  action: "reroll";
+  sessionId: SessionId;
+}
+interface RetryOperation {
+  action: "retry";
+  sessionId: SessionId;
+  turn: number;
+  cascade: CascadePolicy;
+}
+interface RewindOperation {
+  action: "rewind";
+  sessionId: SessionId;
+  toBoundary: number;
+}
+interface RecallOperation {
+  action: "recall";
+  sessionId: SessionId;
+  eventSeq: number;
+}
+interface ForkOperation {
+  action: "fork";
+  sessionId: SessionId;
+  atSeq?: number;
+  childSessionId?: SessionId;
+}
+type SessionEditorOperation = EditOperation | RerollOperation | RetryOperation | RewindOperation | RecallOperation | ForkOperation;
+interface SessionEditorResult {
+  sessionId: SessionId;
+  queuedTurns: number;
+  live?: boolean;
+}
+interface EditableMessageBlock {
+  key: string;
+  turn?: number;
+  eventSeq: number;
+  blockIndex: number;
+  kind: "user" | "assistant.reasoning" | "assistant.response";
+  text: string;
+  time: number;
+}
+interface RetryableTurn {
+  turn: number;
+  userEventSeq: number;
+  preview: string;
+  time: number;
+}
+//#endregion
+//#region src/plan.d.ts
+interface ClosedTurn {
+  turn: number;
+  startSeq: number;
+  endSeq?: number;
+  closed: boolean;
+  user?: SessionEvent<"user/message">;
+  users: SessionEvent<"user/message">[];
+  assistants: SessionEvent<"assistant/message">[];
+}
+interface OperationPlan {
+  anchorSeq: number;
+  rewindBoundary?: number;
+  version: SessionBranchVersionEvent;
+  manualTurn?: {
+    turn: number;
+    user: UserMessage;
+    assistant: AssistantMessage;
+  };
+  queuedUsers: UserMessage[];
+  targetSeq: number;
+}
+declare function closedTurns(events: readonly SessionEvent[]): ClosedTurn[];
+declare function editableMessages(turns: readonly ClosedTurn[]): EditableMessageBlock[];
+declare function retryableTurns(turns: readonly ClosedTurn[]): RetryableTurn[];
+declare function precedingContentIndex(turns: readonly ClosedTurn[], turnIndex: number): number;
+declare function downstreamUsers(turns: readonly ClosedTurn[], start: number): UserMessage[];
+declare function recallBoundary(events: readonly SessionEvent[], turns: readonly ClosedTurn[], eventSeq: number): number;
+declare function editPlan(operation: EditOperation, turns: readonly ClosedTurn[]): OperationPlan;
+declare function retryPlan(operation: RetryOperation, turns: readonly ClosedTurn[]): OperationPlan;
+declare function rerollPlan(operation: RerollOperation, turns: readonly ClosedTurn[]): OperationPlan;
+interface CompactionBracket {
+  start: SessionEvent;
+  summary?: SessionEvent;
+  checkpoint: SessionEvent;
+  end: SessionEvent;
+}
+declare function droppedCompactions(events: readonly SessionEvent[], keepFrom: number, targetSeq: number): CompactionBracket[];
+declare function restoreCompactions(brackets: readonly CompactionBracket[], keepFrom: number, base: number): SessionEvent[];
+//#endregion
+export { SessionEditorResult as C, SessionEditorOperation as S, RecallOperation as _, downstreamUsers as a, RetryableTurn as b, editableMessages as c, rerollPlan as d, restoreCompactions as f, EditableMessageBlock as g, EditOperation as h, closedTurns as i, precedingContentIndex as l, retryableTurns as m, CompactionBracket as n, droppedCompactions as o, retryPlan as p, OperationPlan as r, editPlan as s, ClosedTurn as t, recallBoundary as u, RerollOperation as v, RewindOperation as x, RetryOperation as y };

package/dist/plan.d.cts

@@ -0,0 +1,2 @@
+import { a as downstreamUsers, c as editableMessages, d as rerollPlan, f as restoreCompactions, i as closedTurns, l as precedingContentIndex, m as retryableTurns, n as CompactionBracket, o as droppedCompactions, p as retryPlan, r as OperationPlan, s as editPlan, t as ClosedTurn, u as recallBoundary } from "./plan-CT_6Y1fD.cjs";
+export { ClosedTurn, CompactionBracket, OperationPlan, closedTurns, downstreamUsers, droppedCompactions, editPlan, editableMessages, precedingContentIndex, recallBoundary, rerollPlan, restoreCompactions, retryPlan, retryableTurns };

package/dist/plan.d.mts

@@ -1,2 +1,2 @@
-import { a as editPlan, c as recallBoundary, d as retryableTurns, i as downstreamUsers, l as rerollPlan, n as OperationPlan, o as editableMessages, r as closedTurns, s as precedingContentIndex, t as ClosedTurn, u as retryPlan } from "./plan-BSa7k9HO.mjs";
-export { ClosedTurn, OperationPlan, closedTurns, downstreamUsers, editPlan, editableMessages, precedingContentIndex, recallBoundary, rerollPlan, retryPlan, retryableTurns };
+import { a as downstreamUsers, c as editableMessages, d as rerollPlan, f as restoreCompactions, i as closedTurns, l as precedingContentIndex, m as retryableTurns, n as CompactionBracket, o as droppedCompactions, p as retryPlan, r as OperationPlan, s as editPlan, t as ClosedTurn, u as recallBoundary } from "./plan-Cm9hCord.mjs";
+export { ClosedTurn, CompactionBracket, OperationPlan, closedTurns, downstreamUsers, droppedCompactions, editPlan, editableMessages, precedingContentIndex, recallBoundary, rerollPlan, restoreCompactions, retryPlan, retryableTurns };

package/dist/plan.mjs

@@ -1,3 +1,4 @@
+import { SessionSeq } from "@deepseek-ai/dsh-session";
 import { SESSION_BRANCH_VERSION_SCHEMA, SessionBranchError } from "@morlay/session-branch";
 import { randomUUID } from "node:crypto";
 //#region src/plan.ts
@@ -100,12 +101,6 @@ function retryableTurns(turns) {
 		time: turn.user.time
 	}]);
 }
-/**
-* 目标轮之前最后一个「有内容」轮次的下标：跳过既无用户输入也无助手回复的
-* 空轮。空轮是早期重放缺陷的遗留（turn/start 后直接 turn/end），在轨迹 /
-* 轮次导航里表现为点不开的空项，并让后续轮号出现空洞。rewind 把它们随
-* 目标轮一起截断，重放按保留前缀续号即可自愈。
-*/
 function precedingContentIndex(turns, turnIndex) {
 	let index = turnIndex - 1;
 	while (index >= 0) {
@@ -187,7 +182,8 @@ function editPlan(operation, turns) {
 				edited,
 				...sameTurnFollowups,
 				...later
-			]
+			],
+			targetSeq: event.seq
 		};
 	}
 	if (!turn.closed) throw new SessionBranchError("未闭合轮次的助手消息不可编辑。", "INVALID_BOUNDARY");
@@ -212,7 +208,8 @@ function editPlan(operation, turns) {
 			user: cloneUser(turn.user.data),
 			assistant: assistantReplacement(event, operation.blockIndex, operation.text)
 		},
-		queuedUsers: operation.cascade === "preserve" ? downstreamUsers(turns, turnIndex + 1) : []
+		queuedUsers: operation.cascade === "preserve" ? downstreamUsers(turns, turnIndex + 1) : [],
+		targetSeq: event.seq
 	};
 }
 function retryPlan(operation, turns) {
@@ -227,7 +224,8 @@ function retryPlan(operation, turns) {
 			targetTurn: turn.turn,
 			targetEventSeq: turn.user.seq
 		}),
-		queuedUsers: operation.cascade === "preserve" ? downstreamUsers(turns, turnIndex) : turn.users.map((user) => cloneUser(user.data))
+		queuedUsers: operation.cascade === "preserve" ? downstreamUsers(turns, turnIndex) : turn.users.map((user) => cloneUser(user.data)),
+		targetSeq: turn.user.seq
 	};
 }
 function rerollPlan(operation, turns) {
@@ -244,10 +242,146 @@ function rerollPlan(operation, turns) {
 				targetTurn: turn.turn,
 				targetEventSeq: target.seq
 			}),
-			queuedUsers: turn.users.map((user) => cloneUser(user.data))
+			queuedUsers: turn.users.map((user) => cloneUser(user.data)),
+			targetSeq: target.seq
 		};
 	}
 	throw new SessionBranchError("当前会话没有可重生成的已落定助手回复。", "INVALID_BOUNDARY");
 }
+const COMPACTION_TYPES = /* @__PURE__ */ new Set([
+	"compaction/start",
+	"compaction/summary",
+	"compaction/end"
+]);
+function compactionTypeOf(event) {
+	return COMPACTION_TYPES.has(event.type) ? event.type : void 0;
+}
+function isCompactionCheckpoint(event) {
+	if (event.type !== "user/message") return false;
+	const op = event.surfaceOp;
+	if (typeof op !== "object" || op === null) return false;
+	const source = event.data.source;
+	return source.kind === "plugin" && source.plugin === "compact";
+}
+function compactionBrackets(events) {
+	const brackets = [];
+	let open;
+	for (const event of events) {
+		const type = compactionTypeOf(event);
+		if (type === "compaction/start") {
+			open = { start: event };
+			continue;
+		}
+		if (open === void 0) continue;
+		if (type === "compaction/summary") {
+			open.summary = event;
+			continue;
+		}
+		if (type === "compaction/end") {
+			if (open.checkpoint !== void 0) brackets.push({
+				start: open.start,
+				...open.summary === void 0 ? {} : { summary: open.summary },
+				checkpoint: open.checkpoint,
+				end: event
+			});
+			open = void 0;
+			continue;
+		}
+		if (isCompactionCheckpoint(event)) open.checkpoint = event;
+	}
+	return brackets;
+}
+function droppedCompactions(events, keepFrom, targetSeq) {
+	return compactionBrackets(events).filter((bracket) => bracket.start.seq >= keepFrom && bracket.end.seq < targetSeq);
+}
+function replacementRange(event) {
+	const op = event.surfaceOp;
+	if (op?.op !== "replace") return void 0;
+	if (typeof op.startSeq !== "number" || typeof op.endSeq !== "number") return void 0;
+	return {
+		start: op.startSeq,
+		end: op.endSeq
+	};
+}
+function numberList(value) {
+	return Array.isArray(value) ? value.filter((item) => typeof item === "number") : [];
+}
+function restoreCompactions(brackets, keepFrom, base) {
+	const moved = /* @__PURE__ */ new Map();
+	const resolve = (seq) => seq < keepFrom ? seq : moved.get(seq);
+	const resolveAll = (seqs) => {
+		const resolved = [];
+		for (const seq of seqs) {
+			const next = resolve(seq);
+			if (next === void 0) return void 0;
+			resolved.push(next);
+		}
+		return resolved;
+	};
+	const restored = [];
+	for (const bracket of brackets) {
+		const range = replacementRange(bracket.checkpoint);
+		const shadowedSeqs = resolveAll(numberList((bracket.summary?.data)?.shadowedSeqs));
+		const start = range === void 0 ? void 0 : resolve(range.start);
+		const end = range === void 0 ? void 0 : resolve(range.end);
+		if (start === void 0 || end === void 0 || shadowedSeqs === void 0) continue;
+		const at = base + restored.length;
+		const summary = bracket.summary;
+		const checkpointSeq = at + (summary === void 0 ? 1 : 2);
+		moved.set(bracket.start.seq, at);
+		if (summary !== void 0) moved.set(summary.seq, at + 1);
+		moved.set(bracket.checkpoint.seq, checkpointSeq);
+		moved.set(bracket.end.seq, checkpointSeq + 1);
+		const sources = [
+			at,
+			...summary === void 0 ? [] : [at + 1],
+			...shadowedSeqs
+		];
+		restored.push(standaloneCompaction(bracket.start, at), ...summary === void 0 ? [] : [meteringShadowPrice(summary, at + 1, {
+			start,
+			end
+		}, shadowedSeqs)], replacementCheckpoint(bracket.checkpoint, checkpointSeq, {
+			start,
+			end
+		}, sources), standaloneCompaction(bracket.end, checkpointSeq + 1));
+	}
+	return restored;
+}
+function standaloneCompaction(event, seq) {
+	return {
+		...event,
+		seq: SessionSeq(seq),
+		data: {
+			...event.data,
+			turn: null
+		}
+	};
+}
+function meteringShadowPrice(event, seq, range, shadowedSeqs) {
+	return {
+		...event,
+		seq: SessionSeq(seq),
+		data: {
+			...event.data,
+			shadowedRange: {
+				start: range.start,
+				end: range.end
+			},
+			shadowedSeqs: [...shadowedSeqs]
+		}
+	};
+}
+function replacementCheckpoint(event, seq, range, sources) {
+	return {
+		...event,
+		seq: SessionSeq(seq),
+		surfaceOp: {
+			op: "replace",
+			startSeq: range.start,
+			endSeq: range.end
+		},
+		sourceEventSeqs: [...sources]
+	};
+}
 //#endregion
-export { closedTurns, downstreamUsers, editPlan, editableMessages, precedingContentIndex, recallBoundary, rerollPlan, retryPlan, retryableTurns };
+export { closedTurns, downstreamUsers, droppedCompactions, editPlan, editableMessages, precedingContentIndex, recallBoundary, rerollPlan, restoreCompactions, retryPlan, retryableTurns };

package/dist/shared-LK3nImWW.mjs

@@ -0,0 +1,55 @@
+//#region src/shared.ts
+const SESSION_EDITOR_PATH = "/session-editor";
+function toTimelinePayload(sessionId, timeline, messages, retryableTurns) {
+	const currentPath = /* @__PURE__ */ new Set();
+	for (const node of timeline.nodes) currentPath.add(String(node.sessionId));
+	const versions = timeline.nodes.map((node) => ({
+		sessionId: String(node.sessionId),
+		...node.parentSessionId === void 0 ? {} : { parentSessionId: String(node.parentSessionId) },
+		...node.effect === void 0 ? {} : {
+			effectId: node.effect.id,
+			inverseSessionId: String(node.inverseSessionId),
+			operation: node.effect.operation,
+			cascade: node.effect.cascade,
+			targetTurn: node.effect.targetTurn,
+			...node.effect.blockKind === void 0 ? {} : { blockKind: node.effect.blockKind },
+			...node.effect.before === void 0 ? {} : { before: node.effect.before },
+			...node.effect.after === void 0 ? {} : { 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 = [];
+	let cursor = versionsById.get(String(sessionId));
+	while (cursor?.inverseSessionId !== void 0) {
+		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, sessionId) {
+	const byId = new Map(timeline.nodes.map((node) => [String(node.sessionId), node]));
+	let depth = 0;
+	let cursor = byId.get(String(sessionId));
+	const seen = /* @__PURE__ */ new Set();
+	while (cursor?.parentSessionId !== void 0 && !seen.has(String(cursor.sessionId))) {
+		seen.add(String(cursor.sessionId));
+		depth += 1;
+		cursor = byId.get(String(cursor.parentSessionId));
+	}
+	return depth;
+}
+//#endregion
+export { toTimelinePayload as n, SESSION_EDITOR_PATH as t };