bonecode 1.0.0

package/src/engine/session/provider_transform.ts

@@ -0,0 +1,187 @@
+/**
+ * Provider message transforms — thin re-export wrapper.
+ *
+ * The full transform logic lives in the copied OpenCode file at
+ * src/engine/provider/transform.ts. However, that file uses Effect.js
+ * types and imports. This wrapper extracts the pure functions we need
+ * (message normalization, temperature, topP, topK) and re-exports them
+ * with plain TypeScript signatures.
+ *
+ * For the full provider-specific transforms (Anthropic tool ID scrubbing,
+ * Mistral 9-char IDs, DeepSeek reasoning injection, prompt caching, etc.)
+ * we call the copied functions directly where possible, or inline the
+ * critical transforms here.
+ */
+
+
+// ─── Temperature / sampling defaults (from OpenCode's transform.ts) ───────────
+
+export function temperature(model: { id: string; providerID?: string }): number | undefined {
+  const id = model.id.toLowerCase();
+  if (id.includes("qwen")) return 0.55;
+  if (id.includes("claude")) return undefined;
+  if (id.includes("gemini")) return 1.0;
+  if (id.includes("glm-4.6") || id.includes("glm-4.7")) return 1.0;
+  if (id.includes("minimax-m2")) return 1.0;
+  if (id.includes("kimi-k2")) {
+    if (["thinking", "k2.", "k2p", "k2-5"].some(s => id.includes(s))) return 1.0;
+    return 0.6;
+  }
+  return undefined;
+}
+
+export function topP(model: { id: string }): number | undefined {
+  const id = model.id.toLowerCase();
+  if (id.includes("qwen")) return 1;
+  if (["minimax-m2", "gemini", "kimi-k2.5", "kimi-k2p5", "kimi-k2-5"].some(s => id.includes(s))) return 0.95;
+  return undefined;
+}
+
+export function topK(model: { id: string }): number | undefined {
+  const id = model.id.toLowerCase();
+  if (id.includes("minimax-m2")) return id.includes("m2.") || id.includes("m25") || id.includes("m21") ? 40 : 20;
+  if (id.includes("gemini")) return 64;
+  return undefined;
+}
+
+export const OUTPUT_TOKEN_MAX = 32_000;
+
+export function maxOutputTokens(model: { id: string; limit?: { output?: number } }, outputTokenMax?: number): number {
+  const cap = outputTokenMax ?? OUTPUT_TOKEN_MAX;
+  return model.limit?.output ? Math.min(model.limit.output, cap) : cap;
+}
+
+// ─── Message normalization ────────────────────────────────────────────────────
+// Critical transforms ported from OpenCode's transform.ts normalizeMessages()
+
+function sanitizeSurrogates(content: string): string {
+  return content.replace(/[\uD800-\uDBFF](?![\uDC00-\uDFFF])|(?<![\uD800-\uDBFF])[\uDC00-\uDFFF]/g, "\uFFFD");
+}
+
+export function message(
+  msgs: any[],
+  model: { id: string; providerID: string; api?: { npm?: string } },
+  _options: Record<string, unknown>
+): any[] {
+  const npm = model.api?.npm || "";
+  const id = model.id.toLowerCase();
+
+  // 1. Sanitize surrogates in all text content
+  msgs = msgs.map((msg: any) => {
+    if (msg.role === "system") {
+      return { ...msg, content: sanitizeSurrogates(msg.content) };
+    }
+    if (msg.role === "user") {
+      if (typeof msg.content === "string") return { ...msg, content: sanitizeSurrogates(msg.content) };
+      return { ...msg, content: (msg.content as any[]).map(p => p.type === "text" ? { ...p, text: sanitizeSurrogates(p.text) } : p) };
+    }
+    if (msg.role === "assistant") {
+      if (typeof msg.content === "string") return { ...msg, content: sanitizeSurrogates(msg.content) };
+      return { ...msg, content: (msg.content as any[]).map(p => (p.type === "text" || p.type === "reasoning") ? { ...p, text: sanitizeSurrogates(p.text) } : p) };
+    }
+    return msg;
+  });
+
+  // 2. Anthropic: filter empty content, scrub tool IDs to [a-zA-Z0-9_-]
+  if (npm === "@ai-sdk/anthropic" || id.includes("claude")) {
+    const scrub = (id: string) => id.replace(/[^a-zA-Z0-9_-]/g, "_");
+    msgs = msgs
+      .map(msg => {
+        if (typeof msg.content === "string") {
+          return msg.content === "" ? undefined : msg;
+        }
+        if (!Array.isArray(msg.content)) return msg;
+        const filtered = (msg.content as any[]).filter(p => {
+          if (p.type === "text") return p.text !== "";
+          if (p.type === "reasoning") return p.text?.trim().length > 0 || p.providerOptions?.anthropic?.signature != null;
+          return true;
+        });
+        return filtered.length === 0 ? undefined : { ...msg, content: filtered };
+      })
+      .filter((m: any): m is any => m !== undefined);
+
+    // Scrub tool call IDs
+    msgs = msgs.map((msg: any) => {
+      if (msg.role === "assistant" && Array.isArray(msg.content)) {
+        return { ...msg, content: (msg.content as any[]).map(p => (p.type === "tool-call" || p.type === "tool-result") ? { ...p, toolCallId: scrub(p.toolCallId) } : p) };
+      }
+      if (msg.role === "tool" && Array.isArray(msg.content)) {
+        return { ...msg, content: (msg.content as any[]).map(p => p.type === "tool-result" ? { ...p, toolCallId: scrub(p.toolCallId) } : p) };
+      }
+      return msg;
+    });
+
+    // Reorder: tool_use blocks must not be followed by text in same assistant message
+    msgs = msgs.flatMap((msg: any) => {
+      if (msg.role !== "assistant" || !Array.isArray(msg.content)) return [msg];
+      const parts = msg.content as any[];
+      const first = parts.findIndex(p => p.type === "tool-call");
+      if (first === -1) return [msg];
+      if (!parts.slice(first).some(p => p.type !== "tool-call")) return [msg];
+      return [
+        { ...msg, content: parts.filter(p => p.type !== "tool-call") },
+        { ...msg, content: parts.filter(p => p.type === "tool-call") },
+      ];
+    });
+  }
+
+  // 3. Mistral: 9-char alphanumeric tool IDs, fix tool→user sequence
+  if (model.providerID === "mistral" || id.includes("mistral") || id.includes("devstral")) {
+    const scrub = (id: string) => id.replace(/[^a-zA-Z0-9]/g, "").substring(0, 9).padEnd(9, "0");
+    const result: any[] = [];
+    for (let i = 0; i < msgs.length; i++) {
+      const msg = msgs[i];
+      const next = msgs[i + 1];
+      if (msg.role === "assistant" && Array.isArray(msg.content)) {
+        (msg as any).content = (msg.content as any[]).map(p => (p.type === "tool-call" || p.type === "tool-result") ? { ...p, toolCallId: scrub(p.toolCallId) } : p);
+      }
+      if (msg.role === "tool" && Array.isArray(msg.content)) {
+        (msg as any).content = (msg.content as any[]).map(p => p.type === "tool-result" ? { ...p, toolCallId: scrub(p.toolCallId) } : p);
+      }
+      result.push(msg);
+      if (msg.role === "tool" && next?.role === "user") {
+        result.push({ role: "assistant", content: [{ type: "text", text: "Done." }] });
+      }
+    }
+    return result;
+  }
+
+  // 4. DeepSeek: inject empty reasoning on all assistant messages
+  if (id.includes("deepseek")) {
+    msgs = msgs.map((msg: any) => {
+      if (msg.role !== "assistant") return msg;
+      if (Array.isArray(msg.content)) {
+        if ((msg.content as any[]).some(p => p.type === "reasoning")) return msg;
+        return { ...msg, content: [...(msg.content as any[]), { type: "reasoning", text: "" }] };
+      }
+      return { ...msg, content: [{ type: "text", text: msg.content || "" }, { type: "reasoning", text: "" }] };
+    });
+  }
+
+  return msgs;
+}
+
+// ─── Provider options (prompt caching, etc.) ──────────────────────────────────
+
+export function providerOptions(model: { id: string; providerID: string; api?: { npm?: string } }, options: Record<string, any>): Record<string, any> {
+  const npm = model.api?.npm || "";
+  const id = model.id.toLowerCase();
+
+  // Anthropic prompt caching
+  if (npm === "@ai-sdk/anthropic" || id.includes("claude")) {
+    return { ...options, anthropic: { ...options.anthropic } };
+  }
+  return options;
+}
+
+export function smallOptions(model: { id: string }): Record<string, any> {
+  return {};
+}
+
+export function options(input: { model: { id: string; providerID: string }; sessionID: string; providerOptions?: Record<string, any> }): Record<string, any> {
+  return input.providerOptions || {};
+}
+
+export function schema(model: { id: string }, jsonSchema: any): any {
+  return jsonSchema;
+}

package/src/engine/session/retry.ts

@@ -0,0 +1,200 @@
+import type { NamedError } from "@opencode-ai/core/util/error"
+import { Cause, Clock, Duration, Effect, Schedule } from "effect"
+import { MessageV2 } from "./message-v2"
+import { iife } from "@/util/iife"
+import { isRecord } from "@/util/record"
+
+export type Err = ReturnType<NamedError["toObject"]>
+
+export const GO_UPSELL_MESSAGE = "Free usage exceeded, subscribe to Go"
+export const GO_UPSELL_URL = "https://opencode.ai/go"
+export type RetryReason = "free_tier_limit" | "account_rate_limit" | (string & {})
+
+export type Retryable = {
+  message: string
+  action?: {
+    reason: RetryReason
+    provider: string
+    title: string
+    message: string
+    label: string
+    link?: string
+  }
+}
+
+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)) {
+          // convert seconds to milliseconds
+          return cap(Math.ceil(parsedSeconds * 1000))
+        }
+        // Try parsing as HTTP date format
+        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, provider: string) {
+  // context overflow errors should not be retried
+  if (MessageV2.ContextOverflowError.isInstance(error)) return undefined
+  if (MessageV2.APIError.isInstance(error)) {
+    const status = error.data.statusCode
+    // 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
+    if (error.data.responseBody?.includes("FreeUsageLimitError")) {
+      return {
+        message: GO_UPSELL_MESSAGE,
+        action: {
+          reason: "free_tier_limit",
+          provider,
+          title: "Free limit reached",
+          message: "Subscribe to OpenCode Go for reliable access to the best open-source models, starting at $5/month.",
+          label: "subscribe",
+          link: GO_UPSELL_URL,
+        },
+      }
+    }
+    if (error.data.responseBody?.includes("GoUsageLimitError")) {
+      const body = parseJSON(error.data.responseBody)
+      const workspace = str(body?.metadata?.workspace)
+      const limitName = str(body?.metadata?.limitName)
+      const retryAfter = num(error.data.responseHeaders?.["retry-after"])
+      const resetIn = iife(() => {
+        if (retryAfter === undefined) return ""
+        const seconds = Math.max(0, Math.ceil(retryAfter))
+        const days = Math.floor(seconds / 86_400)
+        const hours = Math.floor((seconds % 86_400) / 3_600)
+        const minutes = Math.ceil((seconds % 3_600) / 60)
+        const unit = (value: number, name: string) => `${value} ${name}${value === 1 ? "" : "s"}`
+
+        if (days > 0) return hours > 0 ? `${unit(days, "day")} ${unit(hours, "hour")}` : unit(days, "day")
+        if (hours > 0) return minutes > 0 ? `${unit(hours, "hour")} ${unit(minutes, "minute")}` : unit(hours, "hour")
+        return minutes > 0 ? unit(minutes, "minute") : "less than a minute"
+      })
+
+      const message = `${limitName ? `${limitName} usage limit` : "Usage limit"} reached. It will reset in ${resetIn}. To continue using this model now, enable usage from your available balance`
+
+      const link = `https://opencode.ai/workspace/${workspace}/go`
+      return {
+        message: `${message} - ${link}`,
+        action: {
+          reason: "account_rate_limit",
+          provider,
+          title: "Go limit reached",
+          message,
+          label: "open settings",
+          link,
+        },
+      }
+    }
+    return { message: error.data.message.includes("Overloaded") ? "Provider is overloaded" : error.data.message }
+  }
+
+  // Check for rate limit patterns in plain text error messages
+  const msg = isRecord(error.data) ? error.data.message : undefined
+  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 { message: msg }
+    }
+  }
+
+  const json = parseJSON(msg)
+  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 { message: "Too Many Requests" }
+  }
+  if (code.includes("exhausted") || code.includes("unavailable")) {
+    return { message: "Provider is overloaded" }
+  }
+  if (json.type === "error" && typeof json.error?.code === "string" && json.error.code.includes("rate_limit")) {
+    return { message: "Rate Limited" }
+  }
+  return undefined
+}
+
+function str(value: unknown) {
+  if (value === undefined || value === null) return ""
+  return String(value)
+}
+
+function num(value: unknown) {
+  const parsed = Number.parseFloat(str(value))
+  if (Number.isNaN(parsed)) return undefined
+  return parsed
+}
+
+function parseJSON(value: unknown) {
+  return iife(() => {
+    try {
+      if (typeof value !== "string") return undefined
+      return JSON.parse(value)
+    } catch {
+      return undefined
+    }
+  })
+}
+
+export function policy(opts: {
+  provider: string
+  parse: (error: unknown) => Err
+  set: (input: { attempt: number; message: string; action?: Retryable["action"]; next: number }) => Effect.Effect<void>
+}) {
+  return Schedule.fromStepWithMetadata(
+    Effect.succeed((meta: Schedule.InputMetadata<unknown>) => {
+      const error = opts.parse(meta.input)
+      const retry = retryable(error, opts.provider)
+      if (!retry) return Cause.done(meta.attempt)
+      return Effect.gen(function* () {
+        const wait = delay(meta.attempt, MessageV2.APIError.isInstance(error) ? error : undefined)
+        const now = yield* Clock.currentTimeMillis
+        yield* opts.set({
+          attempt: meta.attempt,
+          message: retry.message,
+          action: retry.action,
+          next: now + wait,
+        })
+        return [meta.attempt, Duration.millis(wait)] as [number, Duration.Duration]
+      })
+    }),
+  )
+}
+
+export * as SessionRetry from "./retry"

package/src/engine/session/retry_logic.ts

@@ -0,0 +1,65 @@
+/**
+ * Retry logic — pure port from OpenCode's session/retry.ts
+ * No Effect.js dependency. Same algorithm, plain TypeScript.
+ */
+
+export const RETRY_INITIAL_DELAY = 2000;
+export const RETRY_BACKOFF_FACTOR = 2;
+export const RETRY_MAX_DELAY_NO_HEADERS = 30_000;
+export const RETRY_MAX_DELAY = 2_147_483_647;
+
+function cap(ms: number) {
+  return Math.min(ms, RETRY_MAX_DELAY);
+}
+
+export function delay(attempt: number, error?: any): number {
+  if (error) {
+    const headers = error?.data?.responseHeaders || error?.responseHeaders;
+    if (headers) {
+      const retryAfterMs = headers["retry-after-ms"];
+      if (retryAfterMs) {
+        const parsed = Number.parseFloat(retryAfterMs);
+        if (!Number.isNaN(parsed)) return cap(parsed);
+      }
+      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: any, provider: string): { message: string } | undefined {
+  // Context overflow — never retry, triggers compaction instead
+  if (error?.name === "ContextOverflowError" || error?.message?.includes("context_length_exceeded")) return undefined;
+
+  const status = error?.status || error?.statusCode || error?.data?.statusCode;
+  const isRetryable = error?.data?.isRetryable;
+
+  // 5xx always retried
+  if (status !== undefined && status >= 500) return { message: `Server error ${status}` };
+  if (!isRetryable && status !== undefined && status < 500) return undefined;
+
+  const msg = error?.message || error?.data?.message || "";
+  const lower = msg.toLowerCase();
+
+  if (lower.includes("rate limit") || lower.includes("too many requests") || lower.includes("rate increased too quickly")) {
+    return { message: msg };
+  }
+  if (lower.includes("overloaded")) return { message: "Provider is overloaded" };
+  if (lower.includes("exhausted") || lower.includes("unavailable")) return { message: "Provider is overloaded" };
+
+  // Check JSON body
+  try {
+    const body = typeof error?.data?.responseBody === "string" ? JSON.parse(error.data.responseBody) : null;
+    if (body?.type === "error" && body?.error?.type === "too_many_requests") return { message: "Too Many Requests" };
+    if (body?.error?.code?.includes("rate_limit")) return { message: "Rate Limited" };
+  } catch {}
+
+  return undefined;
+}

package/src/engine/session/revert.ts

@@ -0,0 +1,162 @@
+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 "@opencode-ai/core/util/log"
+import * as Session from "./session"
+import { MessageV2 } from "./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),
+})
+export type RevertInput = Schema.Schema.Type<typeof RevertInput>
+
+export interface Interface {
+  readonly revert: (input: RevertInput) => Effect.Effect<Session.Info, Session.BusyError>
+  readonly unrevert: (input: { sessionID: SessionID }) => Effect.Effect<Session.Info, Session.BusyError>
+  readonly cleanup: (session: Session.Info) => Effect.Effect<void>
+}
+
+export class Service extends Context.Service<Service, Interface>()("@opencode/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 }).pipe(Effect.orDie)
+      let lastUser: MessageV2.User | undefined
+      const session = yield* sessions.get(input.sessionID).pipe(Effect.orDie)
+
+      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)
+      yield* snap.revert(patches)
+      if (rev.snapshot) rev.diff = yield* snap.diff(rev.snapshot)
+      const range = all.filter((msg) => msg.info.id >= rev.messageID)
+      const diffs = yield* summary.computeDiff({ messages: range })
+      yield* storage.write(["session_diff", input.sessionID], diffs).pipe(Effect.ignore)
+      yield* bus.publish(Session.Event.Diff, { sessionID: input.sessionID, diff: diffs })
+      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,
+        },
+      })
+      return yield* sessions.get(input.sessionID).pipe(Effect.orDie)
+    })
+
+    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).pipe(Effect.orDie)
+      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).pipe(Effect.orDie)
+    })
+
+    const cleanup = Effect.fn("SessionRevert.cleanup")(function* (session: Session.Info) {
+      if (!session.revert) return
+      const sessionID = session.id
+      const msgs = yield* sessions.messages({ sessionID }).pipe(Effect.orDie)
+      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"