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

package/dist/plan-Bw4zoI4N.d.mts

@@ -0,0 +1,86 @@
+import { BranchTimeline, CascadePolicy, SessionBranchVersionEvent } from "@morlay/session-branch";
+import { SessionEvent, SessionId } from "@deepseek-ai/dsh-session";
+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 ForkOperation {
+  action: "fork";
+  sessionId: SessionId;
+  atSeq?: number;
+  childSessionId?: SessionId;
+}
+type SessionEditorOperation = EditOperation | RerollOperation | RetryOperation | RewindOperation | 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">;
+  /** 轮内全部 user/message（agent 运行中 followup 追加的输入也计入）。 */
+  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[];
+}
+declare function closedTurns(events: readonly SessionEvent[]): ClosedTurn[];
+declare function editableMessages(turns: readonly ClosedTurn[]): EditableMessageBlock[];
+declare function retryableTurns(turns: readonly ClosedTurn[]): RetryableTurn[];
+declare function downstreamUsers(turns: readonly ClosedTurn[], start: number): UserMessage[];
+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;
+//#endregion
+export { SessionEditorResult as _, editPlan as a, retryPlan as c, EditableMessageBlock as d, RerollOperation as f, SessionEditorOperation as g, RewindOperation as h, downstreamUsers as i, retryableTurns as l, RetryableTurn as m, OperationPlan as n, editableMessages as o, RetryOperation as p, closedTurns as r, rerollPlan as s, ClosedTurn as t, EditOperation as u };

package/dist/plan.d.mts

@@ -0,0 +1,2 @@
+import { a as editPlan, c as retryPlan, i as downstreamUsers, l as retryableTurns, n as OperationPlan, o as editableMessages, r as closedTurns, s as rerollPlan, t as ClosedTurn } from "./plan-Bw4zoI4N.mjs";
+export { ClosedTurn, OperationPlan, closedTurns, downstreamUsers, editPlan, editableMessages, rerollPlan, retryPlan, retryableTurns };

package/dist/plan.mjs

@@ -0,0 +1,225 @@
+import { SESSION_BRANCH_VERSION_SCHEMA, SessionBranchError } from "@morlay/session-branch";
+import { randomUUID } from "node:crypto";
+//#region src/plan.ts
+function isTextualBlock(block) {
+	return block?.type === "text" || block?.type === "reasoning";
+}
+function userText(message) {
+	return message.content.filter((block) => block.type === "text").map((block) => block.text).join("\n");
+}
+function cloneUser(message, content = structuredClone(message.content)) {
+	return Object.freeze({
+		id: randomUUID(),
+		role: "user",
+		content: Object.freeze(content),
+		source: Object.freeze({ kind: "user" })
+	});
+}
+function replaceTextBlock(content, blockIndex, text) {
+	const block = content[blockIndex];
+	if (!isTextualBlock(block)) throw new SessionBranchError("所选内容块不是可编辑文本。", "INVALID_BOUNDARY");
+	return content.map((candidate, index) => index === blockIndex ? {
+		...candidate,
+		text
+	} : structuredClone(candidate));
+}
+function closedTurns(events) {
+	const result = [];
+	let current;
+	for (const event of events) {
+		if (event.type === "turn/start") {
+			current = {
+				turn: event.data.turn,
+				startSeq: event.seq,
+				users: [],
+				assistants: []
+			};
+			continue;
+		}
+		if (current === void 0) continue;
+		if (event.type === "user/message" && event.data.source.kind === "user") {
+			if (current.user === void 0) 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 = void 0;
+		}
+	}
+	if (current !== void 0) result.push({
+		...current,
+		closed: false
+	});
+	return result;
+}
+function editableMessages(turns) {
+	const result = [];
+	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
+			});
+		}
+		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) {
+	return turns.flatMap((turn) => turn.user === void 0 || !turn.closed ? [] : [{
+		turn: turn.turn,
+		userEventSeq: turn.user.seq,
+		preview: userText(turn.user.data),
+		time: turn.user.time
+	}]);
+}
+function downstreamUsers(turns, start) {
+	return turns.slice(start).flatMap((turn) => turn.users.map((user) => cloneUser(user.data)));
+}
+function assistantReplacement(event, blockIndex, text) {
+	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
+		})
+	});
+}
+function pairVersionEffect(sourceSessionId, effect) {
+	return {
+		schemaVersion: SESSION_BRANCH_VERSION_SCHEMA,
+		effect: {
+			...effect,
+			id: randomUUID()
+		},
+		inverse: {
+			kind: "restore-version",
+			sessionId: sourceSessionId
+		}
+	};
+}
+function editPlan(operation, turns) {
+	const turnIndex = turns.findIndex((turn) => operation.eventSeq > turn.startSeq && (turn.endSeq === void 0 || operation.eventSeq < turn.endSeq));
+	const turn = turns[turnIndex];
+	if (turn === void 0) 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 === void 0) 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 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,
+			...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
+			]
+		};
+	}
+	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 = before.type === "reasoning" ? "assistant.reasoning" : "assistant.response";
+	if (turn.user === void 0) 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, turns) {
+	const turnIndex = turns.findIndex((turn) => turn.turn === operation.turn);
+	const turn = turns[turnIndex];
+	if (turn?.user === void 0) 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))
+	};
+}
+function rerollPlan(operation, turns) {
+	for (let index = turns.length - 1; index >= 0; index -= 1) {
+		const turn = turns[index];
+		if (turn?.user === void 0 || !turn.closed) continue;
+		const target = turn.assistants.findLast((event) => event.data.message.content.some(isTextualBlock));
+		if (target === void 0) 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");
+}
+//#endregion
+export { closedTurns, downstreamUsers, editPlan, editableMessages, rerollPlan, retryPlan, retryableTurns };