saeeol 1.4.2 → 1.4.3

package/src/session/core/projectors.ts

@@ -1,139 +0,0 @@
-import { NotFoundError } from "@/storage/storage"
-import { eq } from "drizzle-orm"
-import { and } from "drizzle-orm"
-import { SyncEvent } from "@/sync"
-import * as Session from "./session"
-import { MessageV2 } from "../message/message-v2"
-import { SessionTable, MessageTable, PartTable } from "./session.sql"
-import * as Log from "@saeeol/core/util/log"
-
-const log = Log.create({ service: "session.projector" })
-
-function foreign(err: unknown) {
-  if (typeof err !== "object" || err === null) return false
-  if ("code" in err && err.code === "SQLITE_CONSTRAINT_FOREIGNKEY") return true
-  return "message" in err && typeof err.message === "string" && err.message.includes("FOREIGN KEY constraint failed")
-}
-
-export type DeepPartial<T> = T extends object ? { [K in keyof T]?: DeepPartial<T[K]> | null } : T
-
-function grab<T extends object, K1 extends keyof T, X>(
-  obj: T,
-  field1: K1,
-  cb?: (val: NonNullable<T[K1]>) => X,
-): X | undefined {
-  if (obj == undefined || !(field1 in obj)) return undefined
-
-  const val = obj[field1]
-  if (val && typeof val === "object" && cb) {
-    return cb(val)
-  }
-  if (val === undefined) {
-    throw new Error(
-      "Session update failure: pass `null` to clear a field instead of `undefined`: " + JSON.stringify(obj),
-    )
-  }
-  return val as X | undefined
-}
-
-export function toPartialRow(info: DeepPartial<Session.Info>) {
-  const obj = {
-    id: grab(info, "id"),
-    project_id: grab(info, "projectID"),
-    workspace_id: grab(info, "workspaceID"),
-    parent_id: grab(info, "parentID"),
-    slug: grab(info, "slug"),
-    directory: grab(info, "directory"),
-    path: grab(info, "path"),
-    title: grab(info, "title"),
-    version: grab(info, "version"),
-    share_url: grab(info, "share", (v) => grab(v, "url")),
-    summary_additions: grab(info, "summary", (v) => grab(v, "additions")),
-    summary_deletions: grab(info, "summary", (v) => grab(v, "deletions")),
-    summary_files: grab(info, "summary", (v) => grab(v, "files")),
-    summary_diffs: grab(info, "summary", (v) => grab(v, "diffs")),
-    revert: grab(info, "revert"),
-    permission: grab(info, "permission"),
-    time_created: grab(info, "time", (v) => grab(v, "created")),
-    time_updated: grab(info, "time", (v) => grab(v, "updated")),
-    time_compacting: grab(info, "time", (v) => grab(v, "compacting")),
-    time_archived: grab(info, "time", (v) => grab(v, "archived")),
-  }
-
-  return Object.fromEntries(Object.entries(obj).filter(([_, val]) => val !== undefined))
-}
-
-export default [
-  SyncEvent.project(Session.Event.Created, (db, data) => {
-    db.insert(SessionTable)
-      .values(Session.toRow(data.info as Session.Info))
-      .run()
-  }),
-
-  SyncEvent.project(Session.Event.Updated, (db, data) => {
-    const info = data.info
-    const row = db
-      .update(SessionTable)
-      .set(toPartialRow(info as Session.Patch))
-      .where(eq(SessionTable.id, data.sessionID))
-      .returning()
-      .get()
-    if (!row) throw new NotFoundError({ message: `Session not found: ${data.sessionID}` })
-  }),
-
-  SyncEvent.project(Session.Event.Deleted, (db, data) => {
-    db.delete(SessionTable).where(eq(SessionTable.id, data.sessionID)).run()
-  }),
-
-  SyncEvent.project(MessageV2.Event.Updated, (db, data) => {
-    const time_created = data.info.time.created
-    const { id, sessionID, ...rest } = data.info
-
-    try {
-      db.insert(MessageTable)
-        .values({
-          id,
-          session_id: sessionID,
-          time_created,
-          data: rest,
-        })
-        .onConflictDoUpdate({ target: MessageTable.id, set: { data: rest } })
-        .run()
-    } catch (err) {
-      if (!foreign(err)) throw err
-      log.warn("ignored late message update", { messageID: id, sessionID })
-    }
-  }),
-
-  SyncEvent.project(MessageV2.Event.Removed, (db, data) => {
-    db.delete(MessageTable)
-      .where(and(eq(MessageTable.id, data.messageID), eq(MessageTable.session_id, data.sessionID)))
-      .run()
-  }),
-
-  SyncEvent.project(MessageV2.Event.PartRemoved, (db, data) => {
-    db.delete(PartTable)
-      .where(and(eq(PartTable.id, data.partID), eq(PartTable.session_id, data.sessionID)))
-      .run()
-  }),
-
-  SyncEvent.project(MessageV2.Event.PartUpdated, (db, data) => {
-    const { id, messageID, sessionID, ...rest } = data.part
-
-    try {
-      db.insert(PartTable)
-        .values({
-          id,
-          message_id: messageID,
-          session_id: sessionID,
-          time_created: data.time,
-          data: rest,
-        })
-        .onConflictDoUpdate({ target: PartTable.id, set: { data: rest } })
-        .run()
-    } catch (err) {
-      if (!foreign(err)) throw err
-      log.warn("ignored late part update", { partID: id, messageID, sessionID })
-    }
-  }),
-]

package/src/session/core/resolve-tools.ts

@@ -1,241 +0,0 @@
-import { type Tool as AITool, tool, jsonSchema, type ToolExecutionOptions, asSchema } from "ai"
-import { Effect, Context, Layer } from "effect"
-import * as EffectZod from "@/util/effect-zod"
-import { ModelID, ProviderID } from "../../provider/schema"
-import { SessionID, PartID } from "./schema"
-import { MessageV2 } from "../message/message-v2"
-import * as Session from "./session"
-import { Agent } from "../../agent/agent"
-import { Provider } from "@/provider/provider"
-import { ProviderTransform } from "@/provider/transform"
-import { ToolRegistry } from "@/tool/registry"
-import { MCP } from "../../mcp"
-import { Plugin } from "../../plugin"
-import { Permission } from "@/permission"
-import { Truncate } from "@/tool/truncate"
-import { SessionProcessor } from "./processor"
-import { SaeeolSessionPrompt } from "@/saeeol/session/prompt" 
-import { EffectBridge } from "@/effect/bridge"
-import { Tool } from "@/tool/tool"
-import { type TaskPromptOps } from "@/tool/task"
-import * as Log from "@saeeol/core/util/log"
-
-const log = Log.create({ service: "session.resolve-tools" })
-
-export interface ResolveToolsInput {
-  agent: Agent.Info
-  model: Provider.Model
-  session: Session.Info
-  tools?: Record<string, boolean>
-  processor: Pick<SessionProcessor.Handle, "message" | "updateToolCall" | "completeToolCall">
-  bypassAgentCheck: boolean
-  messages: MessageV2.WithParts[]
-}
-
-export interface Interface {
-  readonly resolve: (input: ResolveToolsInput) => Effect.Effect<Record<string, AITool>>
-}
-
-export class Service extends Context.Service<Service, Interface>()("@saeeol/SessionResolveTools") {}
-
-export const layer = Layer.effect(
-  Service,
-  Effect.gen(function* () {
-    const registry = yield* ToolRegistry.Service
-    const plugin = yield* Plugin.Service
-    const permission = yield* Permission.Service
-    const mcp = yield* MCP.Service
-    const truncate = yield* Truncate.Service
-
-    const resolve = Effect.fn("SessionResolveTools.resolve")(function* (input: ResolveToolsInput) {
-      using _ = log.time("resolveTools")
-      const tools: Record<string, AITool> = {}
-      const bridge = yield* EffectBridge.make()
-      const promptOps: TaskPromptOps = {
-        cancel: (sessionID: SessionID) => Effect.void,
-        resolvePromptParts: (template: string) => Effect.succeed([{ type: "text" as const, text: template }]) as any,
-        prompt: (_input: any) => Effect.fail(new Error("not available")) as any,
-      }
-
-      const context = (args: any, options: ToolExecutionOptions): Tool.Context => ({
-        sessionID: input.session.id,
-        abort: options.abortSignal!,
-        messageID: input.processor.message.id,
-        callID: options.toolCallId,
-        extra: { model: input.model, bypassAgentCheck: input.bypassAgentCheck, promptOps },
-        agent: input.agent.name,
-        messages: input.messages,
-        metadata: (val: any) =>
-          input.processor.updateToolCall(options.toolCallId, (match) => {
-            if (!["running", "pending"].includes(match.state.status)) return match
-            return {
-              ...match,
-              state: {
-                title: val.title,
-                metadata: val.metadata,
-                status: "running",
-                input: args,
-                time: { start: Date.now() },
-              },
-            }
-          }),
-        ask: (req: any) =>
-          permission
-            .ask({
-              ...req,
-              sessionID: input.session.id,
-              tool: { messageID: input.processor.message.id, callID: options.toolCallId },
-              ruleset: Permission.merge(
-                input.agent.permission,
-                SaeeolSessionPrompt.guardPermissions({ agent: input.agent, session: input.session }),
-              ),
-              hardRuleset: SaeeolSessionPrompt.hardPermissions({ agent: input.agent }),
-            })
-            .pipe(Effect.orDie),
-      })
-
-      for (const item of yield* registry.tools({
-        modelID: ModelID.make(input.model.api.id),
-        providerID: input.model.providerID,
-        agent: input.agent,
-      })) {
-        const schema = ProviderTransform.schema(input.model, EffectZod.toJsonSchema(item.parameters))
-        tools[item.id] = tool({
-          description: item.description,
-          inputSchema: jsonSchema(schema),
-          execute(args, options) {
-            return bridge.promise(
-              Effect.gen(function* () {
-                const ctx = context(args, options)
-                yield* plugin.trigger(
-                  "tool.execute.before",
-                  { tool: item.id, sessionID: ctx.sessionID, callID: ctx.callID },
-                  { args },
-                )
-                const result = yield* item.execute(args, ctx)
-                const output = {
-                  ...result,
-                  attachments: result.attachments?.map((attachment) => ({
-                    ...attachment,
-                    id: PartID.ascending(),
-                    sessionID: ctx.sessionID,
-                    messageID: input.processor.message.id,
-                  })),
-                }
-                yield* plugin.trigger(
-                  "tool.execute.after",
-                  { tool: item.id, sessionID: ctx.sessionID, callID: ctx.callID, args },
-                  output,
-                )
-                if (options.abortSignal?.aborted) {
-                  yield* input.processor.completeToolCall(options.toolCallId, output)
-                }
-                return output
-              }),
-            )
-          },
-        })
-      }
-
-      for (const [key, item] of Object.entries(yield* mcp.tools())) {
-        const execute = item.execute
-        if (!execute) continue
-        const schema = yield* Effect.promise(() => Promise.resolve(asSchema(item.inputSchema).jsonSchema))
-        const transformed = ProviderTransform.schema(input.model, schema)
-        item.inputSchema = jsonSchema(transformed)
-        item.execute = (args, opts) =>
-          bridge.promise(
-            Effect.gen(function* () {
-              const ctx = context(args, opts)
-              yield* plugin.trigger(
-                "tool.execute.before",
-                { tool: key, sessionID: ctx.sessionID, callID: opts.toolCallId },
-                { args },
-              )
-              const result: Awaited<ReturnType<NonNullable<typeof execute>>> = yield* Effect.gen(function* () {
-                yield* ctx.ask({ permission: key, metadata: {}, patterns: ["*"], always: ["*"] })
-                return yield* Effect.promise(() => execute(args, opts))
-              }).pipe(
-                Effect.withSpan("Tool.execute", {
-                  attributes: {
-                    "tool.name": key,
-                    "tool.call_id": opts.toolCallId,
-                    "session.id": ctx.sessionID,
-                    "message.id": input.processor.message.id,
-                  },
-                }),
-              )
-              yield* plugin.trigger(
-                "tool.execute.after",
-                { tool: key, sessionID: ctx.sessionID, callID: opts.toolCallId, args },
-                result,
-              )
-
-              const textParts: string[] = []
-              const attachments: Omit<MessageV2.FilePart, "id" | "sessionID" | "messageID">[] = []
-              for (const contentItem of result.content) {
-                if (contentItem.type === "text") textParts.push(contentItem.text)
-                else if (contentItem.type === "image") {
-                  attachments.push({
-                    type: "file",
-                    mime: contentItem.mimeType,
-                    url: `data:${contentItem.mimeType};base64,${contentItem.data}`,
-                  })
-                } else if (contentItem.type === "resource") {
-                  const { resource } = contentItem
-                  if (resource.text) textParts.push(resource.text)
-                  if (resource.blob) {
-                    attachments.push({
-                      type: "file",
-                      mime: resource.mimeType ?? "application/octet-stream",
-                      url: `data:${resource.mimeType ?? "application/octet-stream"};base64,${resource.blob}`,
-                      filename: resource.uri,
-                    })
-                  }
-                }
-              }
-
-              const truncated = yield* truncate.output(textParts.join("\n\n"), {}, input.agent)
-              const metadata = {
-                ...result.metadata,
-                truncated: truncated.truncated,
-                ...(truncated.truncated && { outputPath: truncated.outputPath }),
-              }
-              const output = {
-                title: "",
-                metadata,
-                output: truncated.content,
-                attachments: attachments.map((attachment) => ({
-                  ...attachment,
-                  id: PartID.ascending(),
-                  sessionID: ctx.sessionID,
-                  messageID: input.processor.message.id,
-                })),
-                content: result.content,
-              }
-              if (opts.abortSignal?.aborted) {
-                yield* input.processor.completeToolCall(opts.toolCallId, output)
-              }
-              return output
-            }),
-          )
-        tools[key] = item
-      }
-
-      return tools
-    })
-
-    return { resolve }
-  }),
-)
-
-export const defaultLayer = Layer.suspend(() =>
-  layer.pipe(
-    Layer.provide(ToolRegistry.defaultLayer),
-    Layer.provide(MCP.defaultLayer),
-    Layer.provide(Plugin.defaultLayer),
-    Layer.provide(Permission.defaultLayer),
-    Layer.provide(Truncate.defaultLayer),
-    Layer.provide(Provider.defaultLayer),
-  ),
-)

package/src/session/core/retry.ts

@@ -1,145 +0,0 @@
-import type { NamedError } from "@saeeol/core/util/error"
-import { Cause, Clock, Duration, Effect, Schedule } from "effect"
-import { MessageV2 } from "../message/message-v2"
-import { isSaeeolError } from "@/saeeol/errors" 
-import { SessionNetwork } from "./network" 
-import { iife } from "@/util/iife"
-
-export type Err = ReturnType<NamedError["toObject"]>
-
-// This exported message is shared with the TUI upsell detector. Matching on a
-// literal error string kind of sucks, but it is the simplest for now.
-export const GO_UPSELL_MESSAGE = "Free usage exceeded, subscribe to Go https://saeeol.ai/go"
-
-export const RETRY_INITIAL_DELAY = 2000
-export const RETRY_BACKOFF_FACTOR = 2
-export const RETRY_MAX_DELAY_NO_HEADERS = 30_000 // 30 seconds
-export const RETRY_MAX_DELAY = 2_147_483_647 // max 32-bit signed integer for setTimeout
-
-function cap(ms: number) {
-  return Math.min(ms, RETRY_MAX_DELAY)
-}
-
-export function delay(attempt: number, error?: MessageV2.APIError) {
-  if (error) {
-    const headers = error.data.responseHeaders
-    if (headers) {
-      const retryAfterMs = headers["retry-after-ms"]
-      if (retryAfterMs) {
-        const parsedMs = Number.parseFloat(retryAfterMs)
-        if (!Number.isNaN(parsedMs)) {
-          return cap(parsedMs)
-        }
-      }
-
-      const retryAfter = headers["retry-after"]
-      if (retryAfter) {
-        const parsedSeconds = Number.parseFloat(retryAfter)
-        if (!Number.isNaN(parsedSeconds)) {
-          return cap(Math.ceil(parsedSeconds * 1000))
-        }
-        const parsed = Date.parse(retryAfter) - Date.now()
-        if (!Number.isNaN(parsed) && parsed > 0) {
-          return cap(Math.ceil(parsed))
-        }
-      }
-
-      return cap(RETRY_INITIAL_DELAY * Math.pow(RETRY_BACKOFF_FACTOR, attempt - 1))
-    }
-  }
-
-  return cap(Math.min(RETRY_INITIAL_DELAY * Math.pow(RETRY_BACKOFF_FACTOR, attempt - 1), RETRY_MAX_DELAY_NO_HEADERS))
-}
-
-export function retryable(error: Err) {
-  // context overflow errors should not be retried
-  if (MessageV2.ContextOverflowError.isInstance(error)) return undefined
-  if (MessageV2.APIError.isInstance(error)) {
-    const status = error.data.statusCode
-    if (isSaeeolError(error)) return undefined
-
-    // 5xx errors are transient server failures and should always be retried,
-    // even when the provider SDK doesn't explicitly mark them as retryable.
-    if (!error.data.isRetryable && !(status !== undefined && status >= 500)) return undefined
-    // capped model is futile and the backoff loop cannot be broken by switching
-    // models in the chat selector (the retry loop holds a stale model ref).
-    if (error.data.responseBody?.includes("FreeUsageLimitError")) return undefined
-    return error.data.message.includes("Overloaded") ? "Provider is overloaded" : error.data.message
-  }
-  const msg = error.data?.message
-  if (typeof msg === "string") {
-    const lower = msg.toLowerCase()
-    if (
-      lower.includes("rate increased too quickly") ||
-      lower.includes("rate limit") ||
-      lower.includes("too many requests")
-    ) {
-      return msg
-    }
-  }
-
-  const json = iife(() => {
-    try {
-      if (typeof error.data?.message === "string") {
-        const parsed = JSON.parse(error.data.message)
-        return parsed
-      }
-
-      return JSON.parse(error.data.message)
-    } catch {
-      return undefined
-    }
-  })
-  if (!json || typeof json !== "object") return undefined
-  const code = typeof json.code === "string" ? json.code : ""
-
-  if (json.type === "error" && json.error?.type === "too_many_requests") {
-    return "Too Many Requests"
-  }
-  if (code.includes("exhausted") || code.includes("unavailable")) {
-    return "Provider is overloaded"
-  }
-  if (json.type === "error" && typeof json.error?.code === "string" && json.error.code.includes("rate_limit")) {
-    return "Rate Limited"
-  }
-  return undefined
-}
-
-export function policy(opts: {
-  parse: (error: unknown) => Err
-  set: (input: { attempt: number; message: string; next: number }) => Effect.Effect<void>
-  limit?: number
-  offline?: (input: { error: unknown; message: string }) => Effect.Effect<"retry" | "blocked" | "aborted">
-}) {
-  return Schedule.fromStepWithMetadata(
-    Effect.succeed((meta: Schedule.InputMetadata<unknown>) => {
-      if (opts.limit !== undefined && meta.attempt > opts.limit) {
-        return Cause.done(meta.attempt)
-      }
-
-      const error = opts.parse(meta.input)
-      const message = retryable(error)
-      if (!message) return Cause.done(meta.attempt)
-      return Effect.gen(function* () {
-        if (opts.offline && SessionNetwork.disconnected(meta.input)) {
-          const result = yield* opts.offline({
-            error: meta.input,
-            message: SessionNetwork.message(meta.input),
-          })
-          if (result !== "retry") {
-            return yield* Cause.done(meta.attempt)
-          }
-          yield* opts.set({ attempt: 0, message: "Reconnected", next: Date.now() })
-          return [0, Duration.zero] as [number, Duration.Duration]
-        }
-
-        const wait = delay(meta.attempt, MessageV2.APIError.isInstance(error) ? error : undefined)
-        const now = yield* Clock.currentTimeMillis
-        yield* opts.set({ attempt: meta.attempt, message, next: now + wait })
-        return [meta.attempt, Duration.millis(wait)] as [number, Duration.Duration]
-      })
-    }),
-  )
-}
-
-export * as SessionRetry from "./retry"

package/src/session/core/revert.ts

@@ -1,173 +0,0 @@
-import { Effect, Layer, Context, Schema } from "effect"
-import { Bus } from "../../bus"
-import { Snapshot } from "../../snapshot"
-import { Storage } from "@/storage/storage"
-import { SyncEvent } from "../../sync"
-import * as Log from "@saeeol/core/util/log"
-import { zod } from "@/util/effect-zod"
-import { withStatics } from "@/util/schema"
-import * as Session from "./session"
-import { MessageV2 } from "../message/message-v2"
-import { SessionID, MessageID, PartID } from "./schema"
-import { SessionRunState } from "./run-state"
-import { SessionSummary } from "./summary"
-
-const log = Log.create({ service: "session.revert" })
-
-export const RevertInput = Schema.Struct({
-  sessionID: SessionID,
-  messageID: MessageID,
-  partID: Schema.optional(PartID),
-}).pipe(withStatics((s) => ({ zod: zod(s) })))
-export type RevertInput = Schema.Schema.Type<typeof RevertInput>
-
-export interface Interface {
-  readonly revert: (input: RevertInput) => Effect.Effect<Session.Info>
-  readonly unrevert: (input: { sessionID: SessionID }) => Effect.Effect<Session.Info>
-  readonly cleanup: (session: Session.Info) => Effect.Effect<void>
-}
-
-export class Service extends Context.Service<Service, Interface>()("@saeeol/SessionRevert") {}
-
-export const layer = Layer.effect(
-  Service,
-  Effect.gen(function* () {
-    const sessions = yield* Session.Service
-    const snap = yield* Snapshot.Service
-    const storage = yield* Storage.Service
-    const bus = yield* Bus.Service
-    const summary = yield* SessionSummary.Service
-    const state = yield* SessionRunState.Service
-    const sync = yield* SyncEvent.Service
-
-    const revert = Effect.fn("SessionRevert.revert")(function* (input: RevertInput) {
-      yield* state.assertNotBusy(input.sessionID)
-      const all = yield* sessions.messages({ sessionID: input.sessionID })
-      let lastUser: MessageV2.User | undefined
-      const session = yield* sessions.get(input.sessionID)
-
-      let rev: Session.Info["revert"]
-      const patches: Snapshot.Patch[] = []
-      for (const msg of all) {
-        if (msg.info.role === "user") lastUser = msg.info
-        const remaining = []
-        for (const part of msg.parts) {
-          if (rev) {
-            if (part.type === "patch") patches.push(part)
-            continue
-          }
-
-          if (!rev) {
-            if ((msg.info.id === input.messageID && !input.partID) || part.id === input.partID) {
-              const partID = remaining.some((item) => ["text", "tool"].includes(item.type)) ? input.partID : undefined
-              rev = {
-                messageID: !partID && lastUser ? lastUser.id : msg.info.id,
-                partID,
-              }
-            }
-            remaining.push(part)
-          }
-        }
-      }
-
-      if (!rev) return session
-
-      rev.snapshot = session.revert?.snapshot ?? (yield* snap.track())
-      if (session.revert?.snapshot) yield* snap.restore(session.revert.snapshot)
-      // reflects changes being undone (files on disk still have AI modifications)
-      const range = all.filter((msg) => msg.info.id >= rev!.messageID)
-      const diffs = yield* summary.computeDiff({ messages: range })
-
-      yield* snap.revert(patches)
-      if (rev.snapshot) rev.diff = yield* snap.diff(rev.snapshot as string)
-      yield* storage.write(["session_diff", input.sessionID], diffs).pipe(Effect.ignore)
-      yield* bus.publish(Session.Event.Diff, { sessionID: input.sessionID, diff: diffs })
-      const summaryDiffs: Snapshot.SummaryFileDiff[] = diffs.map((d) => ({
-        file: d.file,
-        additions: d.additions,
-        deletions: d.deletions,
-        status: d.status,
-      }))
-      yield* sessions.setRevert({
-        sessionID: input.sessionID,
-        revert: rev,
-        summary: {
-          additions: diffs.reduce((sum, x) => sum + x.additions, 0),
-          deletions: diffs.reduce((sum, x) => sum + x.deletions, 0),
-          files: diffs.length,
-          diffs: summaryDiffs, 
-        },
-      })
-      return yield* sessions.get(input.sessionID)
-    })
-
-    const unrevert = Effect.fn("SessionRevert.unrevert")(function* (input: { sessionID: SessionID }) {
-      log.info("unreverting", input)
-      yield* state.assertNotBusy(input.sessionID)
-      const session = yield* sessions.get(input.sessionID)
-      if (!session.revert) return session
-      if (session.revert.snapshot) yield* snap.restore(session.revert!.snapshot!)
-      yield* sessions.clearRevert(input.sessionID)
-      return yield* sessions.get(input.sessionID)
-    })
-
-    const cleanup = Effect.fn("SessionRevert.cleanup")(function* (session: Session.Info) {
-      if (!session.revert) return
-      const sessionID = session.id
-      const msgs = yield* sessions.messages({ sessionID })
-      const messageID = session.revert.messageID
-      const remove = [] as MessageV2.WithParts[]
-      let target: MessageV2.WithParts | undefined
-      for (const msg of msgs) {
-        if (msg.info.id < messageID) continue
-        if (msg.info.id > messageID) {
-          remove.push(msg)
-          continue
-        }
-        if (session.revert.partID) {
-          target = msg
-          continue
-        }
-        remove.push(msg)
-      }
-      for (const msg of remove) {
-        yield* sync.run(MessageV2.Event.Removed, {
-          sessionID,
-          messageID: msg.info.id,
-        })
-      }
-      if (session.revert.partID && target) {
-        const partID = session.revert.partID
-        const idx = target.parts.findIndex((part) => part.id === partID)
-        if (idx >= 0) {
-          const removeParts = target.parts.slice(idx)
-          target.parts = target.parts.slice(0, idx)
-          for (const part of removeParts) {
-            yield* sync.run(MessageV2.Event.PartRemoved, {
-              sessionID,
-              messageID: target.info.id,
-              partID: part.id,
-            })
-          }
-        }
-      }
-      yield* sessions.clearRevert(sessionID)
-    })
-
-    return Service.of({ revert, unrevert, cleanup })
-  }),
-)
-
-export const defaultLayer = Layer.suspend(() =>
-  layer.pipe(
-    Layer.provide(SessionRunState.defaultLayer),
-    Layer.provide(Session.defaultLayer),
-    Layer.provide(Snapshot.defaultLayer),
-    Layer.provide(Storage.defaultLayer),
-    Layer.provide(Bus.layer),
-    Layer.provide(SessionSummary.defaultLayer),
-    Layer.provide(SyncEvent.defaultLayer),
-  ),
-)
-
-export * as SessionRevert from "./revert"