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

package/dist/index.d.mts

@@ -0,0 +1,105 @@
+import { _ as SessionEditorResult, d as EditableMessageBlock, f as RerollOperation, g as SessionEditorOperation, h as RewindOperation, l as retryableTurns, m as RetryableTurn, o as editableMessages, p as RetryOperation, r as closedTurns, u as EditOperation } from "./plan-Bw4zoI4N.mjs";
+import { Context, Service } from "@deepseek-ai/cordis";
+import { BranchBoundary, BranchTimeline, BranchTimeline as BranchTimeline$1, CascadePolicy, EditableBlockKind, SESSION_BRANCH_VERSION_SCHEMA, SessionBranchVersionEvent } from "@morlay/session-branch";
+import { Session, SessionEvent, SessionId } from "@deepseek-ai/dsh-session";
+import { UserMessage } from "@deepseek-ai/dsh-llm";
+//#region src/index.d.ts
+declare module "@deepseek-ai/cordis" {
+  interface Context {
+    sessionEditor: SessionEditor;
+  }
+}
+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;
+}
+interface EditorAgentHandle {
+  readonly agent: EditorAgent;
+  dispose(): Promise<void>;
+}
+interface EditorAgentRegistry {
+  get(sessionId: SessionId): EditorAgent | undefined;
+  create(options: {
+    sessionId?: SessionId;
+    seed?: readonly SessionEvent[];
+    meta?: {
+      cwd?: string;
+      parentSession?: SessionId;
+      seedLength?: number;
+      agentPreset?: string;
+    };
+    agentOptions?: {
+      provider: string;
+      model: string;
+      maxTokens?: number;
+    };
+  }): Promise<EditorAgentHandle>;
+  resume(options: {
+    resumeSessionId: SessionId;
+    agentOptions?: {
+      provider: string;
+      model: string;
+      maxTokens?: number;
+    };
+  }): Promise<EditorAgentHandle>;
+}
+declare class SessionEditor extends Service {
+  static inject: string[];
+  constructor(ctx: Context);
+  readBranchPrefix(id: SessionId, atSeq?: number, mode?: "after" | "before", signal?: AbortSignal): Promise<BranchBoundary>;
+  fork(sourceId: SessionId, atSeq?: number, childSessionId?: SessionId, meta?: {
+    cwd?: string;
+    agentPreset?: string;
+  }, signal?: AbortSignal): Promise<SessionId>;
+  rewind(id: SessionId, toBoundary: number, signal?: AbortSignal): Promise<import("@deepseek-ai/dsh-session-persistence").SessionPersistenceSnapshot>;
+  timeline(sessionId: SessionId, signal?: AbortSignal): Promise<BranchTimeline$1>;
+  edit(operation: EditOperation, signal?: AbortSignal): Promise<SessionEditorResult>;
+  reroll(operation: RerollOperation, signal?: AbortSignal): Promise<SessionEditorResult>;
+  retry(operation: RetryOperation, signal?: AbortSignal): Promise<SessionEditorResult>;
+  editableMessages(sessionId: SessionId, signal?: AbortSignal): Promise<EditableMessageBlock[]>;
+  retryableTurns(sessionId: SessionId, signal?: AbortSignal): Promise<RetryableTurn[]>;
+  private branchOperation;
+  private readEvents;
+  /**
+   * rewind 前确保 agent 可驱动重放：live agent 先等待其停下（rewind 会截断其
+   * session 内存 log，须在 quiescence 后执行）；cold 会话先 resume 出驻留
+   * agent（此时会话完整，resume 的 prepare 不与截断冲突）。agents 服务缺失或
+   * 无需重放时返回空——调用方退化为就地截断版本。
+   */
+  private prepareReplay;
+}
+interface HttpRequestLike {
+  method?: string;
+  url?: string;
+  on(event: "data", listener: (chunk: Uint8Array | string) => void): this;
+  on(event: "end", listener: () => void): this;
+  on(event: "error", listener: (error: unknown) => void): this;
+}
+interface HttpResponseLike {
+  writeHead(status: number, headers?: Record<string, string>): unknown;
+  end(body?: string): void;
+}
+interface HttpServerLike {
+  register(route: {
+    kind: "exact";
+    path: string;
+    handler: (request: HttpRequestLike, response: HttpResponseLike) => void | Promise<void>;
+  }): () => void;
+}
+declare module "@deepseek-ai/cordis" {
+  interface Context {
+    webServer: HttpServerLike;
+  }
+}
+//#endregion
+export { type BranchTimeline, type CascadePolicy, type EditOperation, type EditableBlockKind, type EditableMessageBlock, EditorAgent, EditorAgentHandle, EditorAgentRegistry, type RerollOperation, type RetryOperation, type RetryableTurn, type RewindOperation, SESSION_BRANCH_VERSION_SCHEMA, type SessionBranchVersionEvent, SessionEditor, SessionEditor as default, type SessionEditorOperation, type SessionEditorResult, closedTurns, editableMessages, retryableTurns };

package/dist/index.mjs

@@ -0,0 +1,3 @@
+import { n as SessionEditor, t as SESSION_BRANCH_VERSION_SCHEMA } from "./src-CXYW0Bc0.mjs";
+import { closedTurns, editableMessages, retryableTurns } from "./plan.mjs";
+export { SESSION_BRANCH_VERSION_SCHEMA, SessionEditor, SessionEditor as default, closedTurns, editableMessages, retryableTurns };

package/dist/invariant.d.mts

@@ -0,0 +1,7 @@
+import { Context } from "@deepseek-ai/cordis";
+//#region src/invariant.d.ts
+declare const name = "ui-conversation-message-actions-invariant";
+declare const inject: string[];
+declare const apply: (ctx: Context) => Promise<() => void>;
+//#endregion
+export { apply, inject, name };

package/dist/invariant.mjs

@@ -0,0 +1,8 @@
+//#region src/invariant.ts
+const PACKAGE_NAME = "@morlay/ui-conversation-message-actions";
+const name = "ui-conversation-message-actions-invariant";
+const inject = ["invariants"];
+const install = () => {};
+const apply = (ctx) => Promise.resolve(ctx.invariants.register(PACKAGE_NAME, install));
+//#endregion
+export { apply, inject, name };

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 };