saeeol 1.2.0 → 1.2.2

package/src/session/revert.ts

@@ -1,173 +1 @@
-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-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"
+export * from "./core/revert"

package/src/session/run-state.ts

@@ -1,110 +1 @@
-import { InstanceState } from "@/effect/instance-state"
-import { Runner } from "@/effect/runner"
-import { Effect, Latch, Layer, Scope, Context } from "effect"
-import * as Session from "./session"
-import { MessageV2 } from "./message-v2"
-import { SessionID } from "./schema"
-import { SessionStatus } from "./status"
-
-export interface Interface {
-  readonly assertNotBusy: (sessionID: SessionID) => Effect.Effect<void>
-  readonly cancel: (sessionID: SessionID) => Effect.Effect<void>
-  readonly ensureRunning: (
-    sessionID: SessionID,
-    onInterrupt: Effect.Effect<MessageV2.WithParts>,
-    work: Effect.Effect<MessageV2.WithParts>,
-  ) => Effect.Effect<MessageV2.WithParts>
-  readonly startShell: (
-    sessionID: SessionID,
-    onInterrupt: Effect.Effect<MessageV2.WithParts>,
-    work: Effect.Effect<MessageV2.WithParts>,
-    ready?: Latch.Latch,
-  ) => Effect.Effect<MessageV2.WithParts>
-}
-
-export class Service extends Context.Service<Service, Interface>()("@saeeol/SessionRunState") {}
-
-export const layer = Layer.effect(
-  Service,
-  Effect.gen(function* () {
-    const status = yield* SessionStatus.Service
-
-    const state = yield* InstanceState.make(
-      Effect.fn("SessionRunState.state")(function* () {
-        const scope = yield* Scope.Scope
-        const runners = new Map<SessionID, Runner.Runner<MessageV2.WithParts>>()
-        yield* Effect.addFinalizer(
-          Effect.fnUntraced(function* () {
-            yield* Effect.forEach(runners.values(), (runner) => runner.cancel, {
-              concurrency: "unbounded",
-              discard: true,
-            })
-            runners.clear()
-          }),
-        )
-        return { runners, scope }
-      }),
-    )
-
-    const runner = Effect.fn("SessionRunState.runner")(function* (
-      sessionID: SessionID,
-      onInterrupt: Effect.Effect<MessageV2.WithParts>,
-    ) {
-      const data = yield* InstanceState.get(state)
-      const existing = data.runners.get(sessionID)
-      if (existing) return existing
-      const next = Runner.make<MessageV2.WithParts>(data.scope, {
-        onIdle: Effect.gen(function* () {
-          data.runners.delete(sessionID)
-          yield* status.set(sessionID, { type: "idle" })
-        }),
-        onBusy: status.set(sessionID, { type: "busy" }),
-        onInterrupt,
-        busy: () => {
-          throw new Session.BusyError(sessionID)
-        },
-      })
-      data.runners.set(sessionID, next)
-      return next
-    })
-
-    const assertNotBusy = Effect.fn("SessionRunState.assertNotBusy")(function* (sessionID: SessionID) {
-      const data = yield* InstanceState.get(state)
-      const existing = data.runners.get(sessionID)
-      if (existing?.busy) throw new Session.BusyError(sessionID)
-    })
-
-    const cancel = Effect.fn("SessionRunState.cancel")(function* (sessionID: SessionID) {
-      const data = yield* InstanceState.get(state)
-      const existing = data.runners.get(sessionID)
-      if (!existing || !existing.busy) {
-        yield* status.set(sessionID, { type: "idle" })
-        return
-      }
-      yield* existing.cancel
-    })
-
-    const ensureRunning = Effect.fn("SessionRunState.ensureRunning")(function* (
-      sessionID: SessionID,
-      onInterrupt: Effect.Effect<MessageV2.WithParts>,
-      work: Effect.Effect<MessageV2.WithParts>,
-    ) {
-      return yield* (yield* runner(sessionID, onInterrupt)).ensureRunning(work)
-    })
-
-    const startShell = Effect.fn("SessionRunState.startShell")(function* (
-      sessionID: SessionID,
-      onInterrupt: Effect.Effect<MessageV2.WithParts>,
-      work: Effect.Effect<MessageV2.WithParts>,
-      ready?: Latch.Latch,
-    ) {
-      return yield* (yield* runner(sessionID, onInterrupt)).startShell(work, ready)
-    })
-
-    return Service.of({ assertNotBusy, cancel, ensureRunning, startShell })
-  }),
-)
-
-export const defaultLayer = layer.pipe(Layer.provide(SessionStatus.defaultLayer))
-
-export * as SessionRunState from "./run-state"
+export * from "./core/run-state"

package/src/session/schema.ts

@@ -1,35 +1 @@
-import { Schema } from "effect"
-
-import { Identifier } from "@/id/id"
-import { zod, ZodOverride } from "@/util/effect-zod"
-import { withStatics } from "@/util/schema"
-
-export const SessionID = Schema.String.annotate({ [ZodOverride]: Identifier.schema("session") }).pipe(
-  Schema.brand("SessionID"),
-  withStatics((s) => ({
-    descending: (id?: string) => s.make(Identifier.descending("session", id)),
-    zod: zod(s),
-  })),
-)
-
-export type SessionID = Schema.Schema.Type<typeof SessionID>
-
-export const MessageID = Schema.String.annotate({ [ZodOverride]: Identifier.schema("message") }).pipe(
-  Schema.brand("MessageID"),
-  withStatics((s) => ({
-    ascending: (id?: string) => s.make(Identifier.ascending("message", id)),
-    zod: zod(s),
-  })),
-)
-
-export type MessageID = Schema.Schema.Type<typeof MessageID>
-
-export const PartID = Schema.String.annotate({ [ZodOverride]: Identifier.schema("part") }).pipe(
-  Schema.brand("PartID"),
-  withStatics((s) => ({
-    ascending: (id?: string) => s.make(Identifier.ascending("part", id)),
-    zod: zod(s),
-  })),
-)
-
-export type PartID = Schema.Schema.Type<typeof PartID>
+export * from "./core/schema"

package/src/session/session-types.ts

@@ -1,160 +1 @@
-import path from "path"
-import { Decimal } from "decimal.js"
-import z from "zod"
-import { type ProviderMetadata, type LanguageModelUsage } from "ai"
-import { InstallationVersion } from "@saeeol/core/installation/version"
-import { BusEvent } from "@/bus/bus-event"
-import { SyncEvent } from "../sync"
-import { PartTable, SessionTable } from "./session.sql"
-import * as Log from "@saeeol/core/util/log"
-import { MessageV2 } from "./message-v2"
-import { Snapshot } from "@/snapshot"
-import { ProjectID } from "../project/schema"
-import { WorkspaceID } from "../control-plane/schema"
-import { SessionID, MessageID, PartID } from "./schema"
-import type { Provider } from "@/provider/provider"
-import { Permission } from "@/permission"
-import { Global } from "@saeeol/core/global"
-import { SaeeolSession } from "@/saeeol/session"
-import { Effect, Schema, Types } from "effect"
-import { zod } from "@/util/effect-zod"
-import { NonNegativeInt, optionalOmitUndefined, withStatics } from "@/util/schema"
-
-const log = Log.create({ service: "session" })
-
-const parentTitlePrefix = "New session - "
-const childTitlePrefix = "Child session - "
-
-export function createDefaultTitle(isChild = false) {
-  return (isChild ? childTitlePrefix : parentTitlePrefix) + new Date().toISOString()
-}
-
-export function isDefaultTitle(title: string) {
-  return new RegExp(`^(${parentTitlePrefix}|${childTitlePrefix})\\d{4}-\\d{2}-\\d{2}T\\d{2}:\\d{2}:\\d{2}\\.\\d{3}Z$`).test(title)
-}
-
-type SessionRow = typeof SessionTable.$inferSelect
-
-export function fromRow(row: SessionRow): Info {
-  const summary = row.summary_additions !== null || row.summary_deletions !== null || row.summary_files !== null
-    ? { additions: row.summary_additions ?? 0, deletions: row.summary_deletions ?? 0, files: row.summary_files ?? 0, diffs: row.summary_diffs ?? undefined }
-    : undefined
-  const share = row.share_url ? { url: row.share_url } : undefined
-  return {
-    id: row.id, slug: row.slug, projectID: row.project_id, workspaceID: row.workspace_id ?? undefined,
-    directory: row.directory, path: row.path ?? undefined, parentID: row.parent_id ?? undefined,
-    title: row.title, version: row.version, summary, share, revert: row.revert ?? undefined,
-    permission: row.permission ?? undefined,
-    time: { created: row.time_created, updated: row.time_updated, compacting: row.time_compacting ?? undefined, archived: row.time_archived ?? undefined },
-  }
-}
-
-export function toRow(info: Info) {
-  return {
-    id: info.id, project_id: info.projectID, workspace_id: info.workspaceID, parent_id: info.parentID,
-    slug: info.slug, directory: info.directory, path: info.path, title: info.title, version: info.version,
-    share_url: info.share?.url, summary_additions: info.summary?.additions, summary_deletions: info.summary?.deletions,
-    summary_files: info.summary?.files, summary_diffs: info.summary?.diffs, revert: info.revert ?? null,
-    permission: info.permission, time_created: info.time.created, time_updated: info.time.updated,
-    time_compacting: info.time.compacting, time_archived: info.time.archived,
-  }
-}
-
-export function getForkedTitle(title: string): string {
-  const match = title.match(/^(.+) \(fork #(\d+)\)$/)
-  if (match) return `${match[1]} (fork #${parseInt(match[2], 10) + 1})`
-  return `${title} (fork #1)`
-}
-
-export function sessionPath(worktree: string, cwd: string) {
-  return path.relative(path.resolve(worktree), cwd).replaceAll("\\", "/")
-}
-
-const Summary = Schema.Struct({ additions: NonNegativeInt, deletions: NonNegativeInt, files: NonNegativeInt, diffs: optionalOmitUndefined(Schema.Array(Snapshot.SummaryFileDiff)) })
-const Share = Schema.Struct({ url: Schema.String })
-export const ArchivedTimestamp = Schema.Finite
-const Time = Schema.Struct({ created: NonNegativeInt, updated: NonNegativeInt, compacting: optionalOmitUndefined(NonNegativeInt), archived: optionalOmitUndefined(ArchivedTimestamp) })
-const Revert = Schema.Struct({ messageID: MessageID, partID: optionalOmitUndefined(PartID), snapshot: optionalOmitUndefined(Schema.String), diff: optionalOmitUndefined(Schema.String) })
-
-export const Info = Schema.Struct({
-  id: SessionID, slug: Schema.String, projectID: ProjectID, workspaceID: optionalOmitUndefined(WorkspaceID),
-  directory: Schema.String, path: optionalOmitUndefined(Schema.String), parentID: optionalOmitUndefined(SessionID),
-  summary: optionalOmitUndefined(Summary), share: optionalOmitUndefined(Share), title: Schema.String,
-  version: Schema.String, time: Time, permission: optionalOmitUndefined(Permission.Ruleset), revert: optionalOmitUndefined(Revert),
-}).annotate({ identifier: "Session" }).pipe(withStatics((s) => ({ zod: zod(s) })))
-export type Info = Types.DeepMutable<Schema.Schema.Type<typeof Info>>
-
-export const ProjectInfo = Schema.Struct({ id: ProjectID, name: optionalOmitUndefined(Schema.String), worktree: Schema.String })
-  .annotate({ identifier: "ProjectSummary" }).pipe(withStatics((s) => ({ zod: zod(s) })))
-export type ProjectInfo = Types.DeepMutable<Schema.Schema.Type<typeof ProjectInfo>>
-
-export const GlobalInfo = Schema.Struct({ ...Info.fields, project: Schema.NullOr(ProjectInfo), worktreeName: Schema.optional(Schema.String) })
-  .annotate({ identifier: "GlobalSession" }).pipe(withStatics((s) => ({ zod: zod(s) })))
-export type GlobalInfo = Types.DeepMutable<Schema.Schema.Type<typeof GlobalInfo>>
-
-export const CreateInput = Schema.optional(Schema.Struct({
-  parentID: Schema.optional(SessionID), title: Schema.optional(Schema.String), permission: Schema.optional(Permission.Ruleset),
-  platform: Schema.optional(Schema.String), workspaceID: Schema.optional(WorkspaceID),
-})).pipe(withStatics((s) => ({ zod: zod(s) })))
-export type CreateInput = Types.DeepMutable<Schema.Schema.Type<typeof CreateInput>>
-
-export const ForkInput = Schema.Struct({ sessionID: SessionID, messageID: Schema.optional(MessageID) }).pipe(withStatics((s) => ({ zod: zod(s) })))
-export const GetInput = SessionID
-export const ChildrenInput = SessionID
-export const RemoveInput = SessionID
-export const SetTitleInput = Schema.Struct({ sessionID: SessionID, title: Schema.String }).pipe(withStatics((s) => ({ zod: zod(s) })))
-export const SetArchivedInput = Schema.Struct({ sessionID: SessionID, time: Schema.optional(ArchivedTimestamp) }).pipe(withStatics((s) => ({ zod: zod(s) })))
-export const SetPermissionInput = Schema.Struct({ sessionID: SessionID, permission: Permission.Ruleset }).pipe(withStatics((s) => ({ zod: zod(s) })))
-export const SetRevertInput = Schema.Struct({ sessionID: SessionID, revert: Schema.optional(Revert), summary: Schema.optional(Summary) }).pipe(withStatics((s) => ({ zod: zod(s) })))
-export const MessagesInput = Schema.Struct({ sessionID: SessionID, limit: Schema.optional(NonNegativeInt) }).pipe(withStatics((s) => ({ zod: zod(s) })))
-
-export type ListInput = { directory?: string; scope?: "project"; path?: string; workspaceID?: WorkspaceID; roots?: boolean; start?: number; search?: string; limit?: number }
-
-const CreatedEventSchema = Schema.Struct({ sessionID: SessionID, info: Info })
-const UpdatedShare = Schema.Struct({ url: Schema.optional(Schema.NullOr(Schema.String)) })
-const UpdatedTime = Schema.Struct({ created: Schema.optional(Schema.NullOr(NonNegativeInt)), updated: Schema.optional(Schema.NullOr(NonNegativeInt)), compacting: Schema.optional(Schema.NullOr(NonNegativeInt)), archived: Schema.optional(Schema.NullOr(ArchivedTimestamp)) })
-const UpdatedInfo = Schema.Struct({
-  id: Schema.optional(Schema.NullOr(SessionID)), slug: Schema.optional(Schema.NullOr(Schema.String)),
-  projectID: Schema.optional(Schema.NullOr(ProjectID)), workspaceID: Schema.optional(Schema.NullOr(WorkspaceID)),
-  directory: Schema.optional(Schema.NullOr(Schema.String)), path: Schema.optional(Schema.NullOr(Schema.String)),
-  parentID: Schema.optional(Schema.NullOr(SessionID)), summary: Schema.optional(Schema.NullOr(Summary)),
-  share: Schema.optional(UpdatedShare), title: Schema.optional(Schema.NullOr(Schema.String)),
-  version: Schema.optional(Schema.NullOr(Schema.String)), time: Schema.optional(UpdatedTime),
-  permission: Schema.optional(Schema.NullOr(Permission.Ruleset)), revert: Schema.optional(Schema.NullOr(Revert)),
-})
-const UpdatedEventSchema = Schema.Struct({ sessionID: SessionID, info: UpdatedInfo })
-
-export const Event = {
-  Created: SyncEvent.define({ type: "session.created", version: 1, aggregate: "sessionID", schema: CreatedEventSchema }),
-  Updated: SyncEvent.define({ type: "session.updated", version: 1, aggregate: "sessionID", schema: UpdatedEventSchema, busSchema: CreatedEventSchema }),
-  Deleted: SyncEvent.define({ type: "session.deleted", version: 1, aggregate: "sessionID", schema: CreatedEventSchema }),
-  Diff: BusEvent.define("session.diff", Schema.Struct({ sessionID: SessionID, diff: Schema.Array(Snapshot.FileDiff) })),
-  Error: BusEvent.define("session.error", Schema.Struct({ sessionID: Schema.optional(SessionID), error: MessageV2.Assistant.fields.error })),
-  TurnOpen: SaeeolSession.Event.TurnOpen,
-  TurnClose: SaeeolSession.Event.TurnClose,
-}
-
-export function plan(input: { slug: string; time: { created: number } }, instance: any) {
-  const base = instance.project.vcs ? path.join(instance.worktree, ".saeeol", "plans") : path.join(Global.Path.data, "plans")
-  return path.join(base, [input.time.created, input.slug].join("-") + ".md")
-}
-
-export const getUsage = (input: { model: Provider.Model; usage: LanguageModelUsage; metadata?: ProviderMetadata; provider?: Provider.Info }) => {
-  const safe = (v: number) => (Number.isFinite(v) ? v : 0)
-  const inputTokens = safe(input.usage.inputTokens ?? 0)
-  const outputTokens = safe(input.usage.outputTokens ?? 0)
-  const reasoningTokens = safe(input.usage.outputTokenDetails?.reasoningTokens ?? input.usage.reasoningTokens ?? 0)
-  const cacheRead = safe(input.usage.inputTokenDetails?.cacheReadTokens ?? input.usage.cachedInputTokens ?? 0)
-  const cacheWrite = safe(Number(input.usage.inputTokenDetails?.cacheWriteTokens ?? input.metadata?.["anthropic"]?.["cacheCreationInputTokens"] ?? input.metadata?.["vertex"]?.["cacheCreationInputTokens"] ?? (input.metadata as any)?.["bedrock"]?.["usage"]?.["cacheWriteInputTokens"] ?? (input.metadata as any)?.["venice"]?.["usage"]?.["cacheCreationInputTokens"] ?? 0))
-  const adjustedInput = safe(inputTokens - cacheRead - cacheWrite)
-  const tokens = { total: input.usage.totalTokens, input: adjustedInput, output: safe(outputTokens - reasoningTokens), reasoning: reasoningTokens, cache: { write: cacheWrite, read: cacheRead } }
-  const reported = SaeeolSession.providerCost({ metadata: input.metadata, usage: input.usage, provider: input.provider, providerID: input.model.providerID })
-  if (reported !== undefined) return { cost: safe(reported), tokens }
-  const costInfo = input.model.cost?.experimentalOver200K && tokens.input + tokens.cache.read > 200_000 ? input.model.cost.experimentalOver200K : input.model.cost
-  return {
-    cost: safe(new Decimal(0).add(new Decimal(tokens.input).mul(costInfo?.input ?? 0).div(1_000_000)).add(new Decimal(tokens.output).mul(costInfo?.output ?? 0).div(1_000_000)).add(new Decimal(tokens.cache.read).mul(costInfo?.cache?.read ?? 0).div(1_000_000)).add(new Decimal(tokens.cache.write).mul(costInfo?.cache?.write ?? 0).div(1_000_000)).add(new Decimal(tokens.reasoning).mul(costInfo?.output ?? 0).div(1_000_000)).toNumber()),
-    tokens,
-  }
-}
-
-export class BusyError extends Error { constructor(public readonly sessionID: string) { super(`Session ${sessionID} is busy`) } }
+export * from "./core/session-types"

package/src/session/session.sql.ts

@@ -1,124 +1 @@
-import { sqliteTable, text, integer, index, primaryKey } from "drizzle-orm/sqlite-core"
-import { ProjectTable } from "../project/project.sql"
-import type { MessageV2 } from "./message-v2"
-import type { SessionEntry } from "../v2/session-entry"
-import type { Snapshot } from "../snapshot"
-import type { Permission } from "../permission"
-import type { ProjectID } from "../project/schema"
-import type { SessionID, MessageID, PartID } from "./schema"
-import type { WorkspaceID } from "../control-plane/schema"
-import { Timestamps } from "../storage/schema.sql"
-
-type PartData = Omit<MessageV2.Part, "id" | "sessionID" | "messageID">
-type InfoData = Omit<MessageV2.Info, "id" | "sessionID">
-
-export const SessionTable = sqliteTable(
-  "session",
-  {
-    id: text().$type<SessionID>().primaryKey(),
-    project_id: text()
-      .$type<ProjectID>()
-      .notNull()
-      .references(() => ProjectTable.id, { onDelete: "cascade" }),
-    workspace_id: text().$type<WorkspaceID>(),
-    parent_id: text().$type<SessionID>(),
-    slug: text().notNull(),
-    directory: text().notNull(),
-    path: text(),
-    title: text().notNull(),
-    version: text().notNull(),
-    share_url: text(),
-    summary_additions: integer(),
-    summary_deletions: integer(),
-    summary_files: integer(),
-    summary_diffs: text({ mode: "json" }).$type<Snapshot.SummaryFileDiff[]>(), 
-    revert: text({ mode: "json" }).$type<{ messageID: MessageID; partID?: PartID; snapshot?: string; diff?: string }>(),
-    permission: text({ mode: "json" }).$type<Permission.Ruleset>(),
-    ...Timestamps,
-    time_compacting: integer(),
-    time_archived: integer(),
-  },
-  (table) => [
-    index("session_project_idx").on(table.project_id),
-    index("session_workspace_idx").on(table.workspace_id),
-    index("session_parent_idx").on(table.parent_id),
-  ],
-)
-
-export const MessageTable = sqliteTable(
-  "message",
-  {
-    id: text().$type<MessageID>().primaryKey(),
-    session_id: text()
-      .$type<SessionID>()
-      .notNull()
-      .references(() => SessionTable.id, { onDelete: "cascade" }),
-    ...Timestamps,
-    data: text({ mode: "json" }).notNull().$type<InfoData>(),
-  },
-  (table) => [index("message_session_time_created_id_idx").on(table.session_id, table.time_created, table.id)],
-)
-
-export const PartTable = sqliteTable(
-  "part",
-  {
-    id: text().$type<PartID>().primaryKey(),
-    message_id: text()
-      .$type<MessageID>()
-      .notNull()
-      .references(() => MessageTable.id, { onDelete: "cascade" }),
-    session_id: text().$type<SessionID>().notNull(),
-    ...Timestamps,
-    data: text({ mode: "json" }).notNull().$type<PartData>(),
-  },
-  (table) => [
-    index("part_message_id_id_idx").on(table.message_id, table.id),
-    index("part_session_idx").on(table.session_id),
-  ],
-)
-
-export const TodoTable = sqliteTable(
-  "todo",
-  {
-    session_id: text()
-      .$type<SessionID>()
-      .notNull()
-      .references(() => SessionTable.id, { onDelete: "cascade" }),
-    content: text().notNull(),
-    status: text().notNull(),
-    priority: text().notNull(),
-    position: integer().notNull(),
-    ...Timestamps,
-  },
-  (table) => [
-    primaryKey({ columns: [table.session_id, table.position] }),
-    index("todo_session_idx").on(table.session_id),
-  ],
-)
-
-export const SessionEntryTable = sqliteTable(
-  "session_entry",
-  {
-    id: text().$type<SessionEntry.ID>().primaryKey(),
-    session_id: text()
-      .$type<SessionID>()
-      .notNull()
-      .references(() => SessionTable.id, { onDelete: "cascade" }),
-    type: text().$type<SessionEntry.Type>().notNull(),
-    ...Timestamps,
-    data: text({ mode: "json" }).notNull().$type<Omit<SessionEntry.Entry, "type" | "id">>(),
-  },
-  (table) => [
-    index("session_entry_session_idx").on(table.session_id),
-    index("session_entry_session_type_idx").on(table.session_id, table.type),
-    index("session_entry_time_created_idx").on(table.time_created),
-  ],
-)
-
-export const PermissionTable = sqliteTable("permission", {
-  project_id: text()
-    .primaryKey()
-    .references(() => ProjectTable.id, { onDelete: "cascade" }),
-  ...Timestamps,
-  data: text({ mode: "json" }).notNull().$type<Permission.Ruleset>(),
-})
+export * from "./core/session.sql"