@morlay/ui-conversation-message-actions 0.0.19-alpha.2 → 0.0.19-alpha.4

package/src/index.ts

@@ -13,35 +13,28 @@ import {
   SessionBranchError,
   balanceRewindPrefix,
   type BranchBoundary,
-  type BranchTimeline,
 } from "@morlay/session-branch";
 import type {
   EditOperation,
-  EditableMessageBlock,
   RecallOperation,
   RerollOperation,
   RetryOperation,
-  RetryableTurn,
   SessionEditorResult,
 } from "./types.ts";
 import {
   SESSION_EDITOR_PATH,
   type SessionEditorOperation,
   type SessionEditorOperationResult,
-  type SessionEditorTimeline,
-  toTimelinePayload,
 } from "./shared.ts";
 import {
   closedTurns,
   droppedCompactions,
-  editableMessages,
   editPlan,
   precedingContentIndex,
   recallBoundary,
   restoreCompactions,
   retryPlan,
   rerollPlan,
-  retryableTurns,
 } from "./plan.ts";
 
 export type { CascadePolicy, EditableBlockKind } from "@morlay/session-branch";
@@ -57,10 +50,7 @@ export type {
   SessionEditorResult,
 } from "./types.ts";
 
-export { closedTurns, editableMessages, retryableTurns };
-export { SESSION_BRANCH_VERSION_SCHEMA } from "@morlay/session-branch";
-
-export type { BranchTimeline, SessionBranchVersionEvent } from "@morlay/session-branch";
+export { closedTurns, editableMessages, retryableTurns } from "./plan.ts";
 
 declare module "@deepseek-ai/cordis" {
   interface Context {
@@ -102,18 +92,12 @@ export interface EditorAgentRegistry {
   }): Promise<EditorAgentHandle>;
 }
 
-function appendLogSeedEvent(
-  events: SessionEvent[],
-  type: string,
-  data: unknown,
-  ignorable = false,
-): void {
+function appendLogSeedEvent(events: SessionEvent[], type: string, data: unknown): void {
   events.push({
     type: type as SessionEvent["type"],
     seq: events.length,
     time: Date.now(),
     data: data as SessionEvent["data"],
-    ...(ignorable ? { ignorable: true as const } : {}),
   } as SessionEvent);
 }
 
@@ -165,22 +149,8 @@ function keepFromOf(events: readonly SessionEvent[], boundary: number): number {
 async function appendSeedSuffixLive(
   session: Session,
   seedSuffix: readonly SessionEvent[],
-  appendDirect: (events: readonly SessionEvent[]) => Promise<void>,
 ): Promise<void> {
   for (const event of seedSuffix) {
-    const ignorable = (event as { ignorable?: boolean }).ignorable === true;
-    if (ignorable) {
-      const s = session as unknown as {
-        log: SessionEvent[];
-        eventsSnapshot?: unknown;
-      };
-
-      const seq = s.log.length;
-      await appendDirect([{ ...event, seq } as SessionEvent]);
-      s.log.push({ ...event, seq } as SessionEvent);
-      s.eventsSnapshot = undefined;
-      continue;
-    }
     const s = session as unknown as {
       append(
         type: string,
@@ -244,10 +214,6 @@ export class SessionEditor extends Service {
     return this.ctx.sessionBranch.rewind(id, toBoundary, signal);
   }
 
-  timeline(sessionId: SessionId, signal?: AbortSignal): Promise<BranchTimeline> {
-    return this.ctx.sessionBranch.timeline(sessionId, signal);
-  }
-
   edit(operation: EditOperation, signal?: AbortSignal): Promise<SessionEditorResult> {
     return this.branchOperation(operation, signal);
   }
@@ -264,19 +230,6 @@ export class SessionEditor extends Service {
     return this.recallOperation(operation, signal);
   }
 
-  async editableMessages(
-    sessionId: SessionId,
-    signal?: AbortSignal,
-  ): Promise<EditableMessageBlock[]> {
-    const events = await this.readEvents(sessionId, signal);
-    return editableMessages(closedTurns(events));
-  }
-
-  async retryableTurns(sessionId: SessionId, signal?: AbortSignal): Promise<RetryableTurn[]> {
-    const events = await this.readEvents(sessionId, signal);
-    return retryableTurns(closedTurns(events));
-  }
-
   private async branchOperation(
     operation: EditOperation | RerollOperation | RetryOperation,
     signal?: AbortSignal,
@@ -309,8 +262,6 @@ export class SessionEditor extends Service {
 
     const replayTurn = preceding < 0 ? 1 : turns[preceding]!.turn + 1;
 
-    const versionSeed: SessionEvent[] = [];
-    appendLogSeedEvent(versionSeed, "session-branch/version", plan.version, true);
     const manualSeed: SessionEvent[] = [];
     if (plan.manualTurn !== undefined) {
       appendManualTurn(manualSeed, { ...plan.manualTurn, turn: replayTurn });
@@ -326,11 +277,10 @@ export class SessionEditor extends Service {
     await this.stopLoop(operation.sessionId, signal);
     const live = this.ctx.sessions.get(operation.sessionId);
     await this.ctx.sessionBranch.rewind(operation.sessionId, boundary, signal);
-    // 补回的压缩落在版本效果之后、重放的输入之前
+    // 补回的压缩落在重放的输入之前
     const seedStart = this.seedStart(live, events, keepFrom);
     const seedSuffix: SessionEvent[] = [
-      ...versionSeed,
-      ...restoreCompactions(compactions, keepFrom, seedStart + versionSeed.length),
+      ...restoreCompactions(compactions, keepFrom, seedStart),
       ...manualSeed,
     ];
     await this.appendSeedSuffix(operation.sessionId, live, seedSuffix, events, keepFrom);
@@ -402,22 +352,8 @@ export class SessionEditor extends Service {
   ): Promise<void> {
     if (seedSuffix.length === 0) return;
     if (live !== undefined) {
-      const persistence = this.ctx.sessionPersistence as unknown as {
-        tracker: {
-          writerOf(id: SessionId):
-            | {
-                append(events: readonly SessionEvent[]): Promise<void>;
-              }
-            | undefined;
-        };
-      };
-      const handle = persistence.tracker.writerOf(sessionId);
-      if (handle === undefined) {
-        throw new Error(`session "${sessionId}" has no live write handle for the version effect`);
-      }
-
       await this.ctx.sessions.flush(live);
-      await appendSeedSuffixLive(live, seedSuffix, (batch) => handle.append(batch));
+      await appendSeedSuffixLive(live, seedSuffix);
       await this.ctx.sessions.flush(live);
       return;
     }
@@ -631,16 +567,6 @@ function respondJson(response: HttpResponseLike, status: number, value: unknown)
   response.end(JSON.stringify(value));
 }
 
-async function readTimeline(
-  editor: SessionEditor,
-  sessionId: SessionId,
-): Promise<SessionEditorTimeline> {
-  const timeline = await editor.timeline(sessionId);
-  const messages = await editor.editableMessages(sessionId);
-  const retryable = await editor.retryableTurns(sessionId);
-  return toTimelinePayload(sessionId, timeline, messages, retryable);
-}
-
 async function runOperation(
   editor: SessionEditor,
   operation: SessionEditorOperation,
@@ -699,12 +625,6 @@ async function handleRoute(
   response: HttpResponseLike,
 ): Promise<void> {
   try {
-    if (request.method === "GET") {
-      const url = new URL(request.url ?? SESSION_EDITOR_PATH, "http://session-editor.local");
-      const sessionId = sessionIdOf(url.searchParams.get("sessionId"));
-      respondJson(response, 200, await readTimeline(editor, sessionId));
-      return;
-    }
     if (request.method === "POST") {
       respondJson(
         response,
@@ -736,62 +656,4 @@ function registerHttpRoutes(ctx: Context): void {
       handler: (request, response) => handleRoute(editor, request, response),
     });
   }, "session-editor: HTTP route");
-
-  const registerConnectionRoute = (): void => {
-    const connection = ctx.get("connection", false) as
-      | {
-          fetch: {
-            register(route: {
-              path: string;
-              methods: readonly ("GET" | "HEAD" | "POST")[];
-              requestBody: "buffered" | "streaming";
-              fetch: (request: Request) => Promise<Response>;
-            }): () => Promise<void>;
-          };
-        }
-      | undefined;
-    if (connection === undefined) return;
-    const editor = ctx.sessionEditor;
-    ctx.effect(
-      () =>
-        connection.fetch.register({
-          path: `/api${SESSION_EDITOR_PATH}`,
-          methods: ["GET", "POST"],
-          requestBody: "buffered",
-          fetch: (request) => handleFetchRoute(editor, request),
-        }),
-      "session-editor: connection fetch route",
-    );
-  };
-  ctx.on("internal/service", (name) => {
-    if (name === "connection") registerConnectionRoute();
-  });
-  registerConnectionRoute();
-}
-
-async function handleFetchRoute(editor: SessionEditor, request: Request): Promise<Response> {
-  try {
-    if (request.method === "GET") {
-      const url = new URL(request.url);
-      const sessionId = sessionIdOf(url.searchParams.get("sessionId"));
-      return jsonResponse(200, await readTimeline(editor, sessionId));
-    }
-    if (request.method === "POST") {
-      return jsonResponse(200, await runOperation(editor, decodeOperation(await request.json())));
-    }
-    return new Response(null, { status: 405 });
-  } catch (error: unknown) {
-    const message = error instanceof Error ? error.message : String(error);
-    return jsonResponse(error instanceof TypeError ? 400 : 409, { error: message });
-  }
-}
-
-function jsonResponse(status: number, value: unknown): Response {
-  return new Response(JSON.stringify(value), {
-    status,
-    headers: {
-      "content-type": "application/json; charset=utf-8",
-      "cache-control": "no-store",
-    },
-  });
 }

package/src/plan.ts

@@ -1,14 +1,8 @@
 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,
-  SessionBranchError,
-  type EditableBlockKind,
-  type SessionBranchEffect,
-  type SessionBranchVersionEvent,
-} from "@morlay/session-branch";
+import type { SessionEvent } from "@deepseek-ai/dsh-session";
+import { SessionBranchError } from "@morlay/session-branch";
 import type {
   EditOperation,
   EditableMessageBlock,
@@ -34,7 +28,6 @@ export interface OperationPlan {
   anchorSeq: number;
 
   rewindBoundary?: number;
-  version: SessionBranchVersionEvent;
 
   manualTurn?: { turn: number; user: UserMessage; assistant: AssistantMessage };
 
@@ -220,17 +213,6 @@ function assistantReplacement(
   }) 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) =>
@@ -262,16 +244,6 @@ export function editPlan(operation: EditOperation, turns: readonly ClosedTurn[])
       anchorSeq: turn.startSeq,
 
       ...(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],
       targetSeq: event.seq,
     };
@@ -282,22 +254,10 @@ export function editPlan(operation: EditOperation, turns: readonly ClosedTurn[])
   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),
@@ -315,12 +275,6 @@ export function retryPlan(operation: RetryOperation, turns: readonly ClosedTurn[
     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)
@@ -343,12 +297,6 @@ export function rerollPlan(
     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)),
       targetSeq: target.seq,
     };

package/src/shared.ts

@@ -1,6 +1,5 @@
 import type { SessionId } from "@deepseek-ai/dsh-session";
-import type { BranchTimeline, CascadePolicy } from "@morlay/session-branch";
-import type { VersionOperation } from "@morlay/session-branch";
+import type { CascadePolicy } from "@morlay/session-branch";
 
 export const SESSION_EDITOR_PATH = "/session-editor";
 
@@ -79,97 +78,3 @@ export interface RetryableTurn {
   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

@@ -9,7 +9,6 @@ import {
   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";
@@ -17,7 +16,6 @@ import { SESSION_EDITOR_PATH } from "./shared.ts";
 import { SessionEditor } from "@morlay/ui-conversation-message-actions";
 
 export {
-  BranchTimeline,
   SESSION_EDITOR_PATH,
   Session,
   SessionIdBrand,

package/src/types.ts

@@ -1,5 +1,5 @@
 import type { SessionId } from "@deepseek-ai/dsh-session";
-import type { BranchTimeline, CascadePolicy } from "@morlay/session-branch";
+import type { CascadePolicy } from "@morlay/session-branch";
 
 export interface EditOperation {
   action: "edit";
@@ -61,8 +61,6 @@ export interface SessionEditorResult {
   live?: boolean;
 }
 
-export type SessionEditorTimeline = BranchTimeline;
-
 export interface EditableMessageBlock {
   key: string;
 

package/dist/shared-LK3nImWW.mjs

@@ -1,55 +0,0 @@
-//#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 };