@neurocode-ai/core 1.18.8

package/src/session/context-epoch.ts

@@ -0,0 +1,174 @@
+export * as SessionContextEpoch from "./context-epoch"
+
+import { eq } from "drizzle-orm"
+import { DateTime, Effect, Schema } from "effect"
+import type { Database } from "../database/database"
+import { EventV2 } from "../event"
+import { SystemContext } from "../system-context/index"
+import { ContextSnapshotDecodeError } from "./error"
+import { SessionEvent } from "./event"
+import { SessionHistory } from "./history"
+import { SessionInput } from "./input"
+import { SessionMessage } from "./message"
+import { SessionSchema } from "./schema"
+import { SessionContextEpochTable } from "./sql"
+
+type DatabaseService = Database.Interface["db"]
+
+interface Prepared {
+  readonly baseline: string
+  readonly baselineSeq: number
+}
+
+export function initialize(
+  db: DatabaseService,
+  context: Effect.Effect<SystemContext.SystemContext>,
+  sessionID: SessionSchema.ID,
+): Effect.Effect<Prepared | undefined, SystemContext.InitializationBlocked> {
+  return initializeOnce(db, context, sessionID).pipe(Effect.withSpan("SessionContextEpoch.initialize"))
+}
+
+export function prepare(
+  db: DatabaseService,
+  events: EventV2.Interface,
+  context: Effect.Effect<SystemContext.SystemContext>,
+  sessionID: SessionSchema.ID,
+): Effect.Effect<Prepared, SystemContext.InitializationBlocked | ContextSnapshotDecodeError> {
+  return prepareOnce(db, events, context, sessionID).pipe(Effect.withSpan("SessionContextEpoch.prepare"))
+}
+
+const prepareOnce = Effect.fnUntraced(function* (
+  db: DatabaseService,
+  events: EventV2.Interface,
+  context: Effect.Effect<SystemContext.SystemContext>,
+  sessionID: SessionSchema.ID,
+) {
+  const [value, stored, compaction] = yield* Effect.all(
+    [context, find(db, sessionID), SessionHistory.latestCompaction(db, sessionID)],
+    { concurrency: "unbounded" },
+  )
+  if (!stored) {
+    const generation = yield* SystemContext.initialize(value)
+    const baselineSeq = yield* insert(db, sessionID, generation)
+    return { baseline: generation.baseline, baselineSeq }
+  }
+
+  const snapshot = yield* Schema.decodeUnknownEffect(SystemContext.Snapshot)(stored.snapshot).pipe(
+    Effect.mapError((error) => new ContextSnapshotDecodeError({ sessionID, details: String(error) })),
+  )
+  const replacementSeq = compaction !== undefined && compaction.seq > stored.baseline_seq ? compaction.seq : undefined
+  const result = replacementSeq
+    ? yield* SystemContext.replace(value, snapshot)
+    : yield* SystemContext.reconcile(value, snapshot)
+  if (result._tag === "Unchanged" || result._tag === "ReplacementBlocked") {
+    return { baseline: stored.baseline, baselineSeq: stored.baseline_seq }
+  }
+  if (result._tag === "ReplacementReady") {
+    const baselineSeq = replacementSeq ?? (yield* EventV2.latestSequence(db, sessionID))
+    yield* replace(db, sessionID, baselineSeq, result.generation)
+    return { baseline: result.generation.baseline, baselineSeq }
+  }
+
+  yield* events.publish(
+    SessionEvent.ContextUpdated,
+    { sessionID, messageID: SessionMessage.ID.create(), timestamp: yield* DateTime.now, text: result.text },
+    { commit: () => advance(db, sessionID, result.snapshot).pipe(Effect.orDie) },
+  )
+  return { baseline: stored.baseline, baselineSeq: stored.baseline_seq }
+})
+
+const initializeOnce = Effect.fnUntraced(function* (
+  db: DatabaseService,
+  context: Effect.Effect<SystemContext.SystemContext>,
+  sessionID: SessionSchema.ID,
+) {
+  if (yield* exists(db, sessionID)) return
+  const generation = yield* context.pipe(Effect.flatMap(SystemContext.initialize))
+  const baselineSeq = yield* insert(db, sessionID, generation)
+  return { baseline: generation.baseline, baselineSeq }
+})
+
+const exists = Effect.fn("SessionContextEpoch.exists")(function* (db: DatabaseService, sessionID: SessionSchema.ID) {
+  return (
+    (yield* db
+      .select({ sessionID: SessionContextEpochTable.session_id })
+      .from(SessionContextEpochTable)
+      .where(eq(SessionContextEpochTable.session_id, sessionID))
+      .get()
+      .pipe(Effect.orDie)) !== undefined
+  )
+})
+
+const find = Effect.fn("SessionContextEpoch.find")(function* (db: DatabaseService, sessionID: SessionSchema.ID) {
+  return yield* db
+    .select()
+    .from(SessionContextEpochTable)
+    .where(eq(SessionContextEpochTable.session_id, sessionID))
+    .get()
+    .pipe(Effect.orDie)
+})
+
+export const reset = Effect.fn("SessionContextEpoch.reset")(function* (
+  db: DatabaseService,
+  sessionID: SessionSchema.ID,
+) {
+  yield* db
+    .delete(SessionContextEpochTable)
+    .where(eq(SessionContextEpochTable.session_id, sessionID))
+    .run()
+    .pipe(Effect.orDie)
+})
+
+const insert = Effect.fnUntraced(function* (
+  db: DatabaseService,
+  sessionID: SessionSchema.ID,
+  generation: SystemContext.Generation,
+) {
+  const baselineSeq = yield* EventV2.latestSequence(db, sessionID)
+  yield* db
+    .insert(SessionContextEpochTable)
+    .values({
+      session_id: sessionID,
+      baseline: generation.baseline,
+      snapshot: generation.snapshot,
+      baseline_seq: baselineSeq,
+    })
+    .run()
+    .pipe(Effect.orDie)
+  return baselineSeq
+})
+
+const replace = Effect.fnUntraced(function* (
+  db: DatabaseService,
+  sessionID: SessionSchema.ID,
+  baselineSeq: number,
+  generation: SystemContext.Generation,
+) {
+  const updated = yield* db
+    .update(SessionContextEpochTable)
+    .set({
+      baseline: generation.baseline,
+      snapshot: generation.snapshot,
+      baseline_seq: baselineSeq,
+    })
+    .where(eq(SessionContextEpochTable.session_id, sessionID))
+    .returning({ sessionID: SessionContextEpochTable.session_id })
+    .get()
+    .pipe(Effect.orDie)
+  if (!updated) return yield* Effect.die("Context Epoch not found")
+})
+
+const advance = Effect.fnUntraced(function* (
+  db: DatabaseService,
+  sessionID: SessionSchema.ID,
+  snapshot: SystemContext.Snapshot,
+) {
+  const updated = yield* db
+    .update(SessionContextEpochTable)
+    .set({ snapshot })
+    .where(eq(SessionContextEpochTable.session_id, sessionID))
+    .returning({ sessionID: SessionContextEpochTable.session_id })
+    .get()
+    .pipe(Effect.orDie)
+  if (!updated) return yield* Effect.die("Context Epoch not found")
+})

package/src/session/error.ts

@@ -0,0 +1,24 @@
+import { Schema } from "effect"
+import { SessionMessage } from "./message"
+import { SessionSchema } from "./schema"
+
+export class MessageDecodeError extends Schema.TaggedErrorClass<MessageDecodeError>()("Session.MessageDecodeError", {
+  sessionID: SessionSchema.ID,
+  messageID: SessionMessage.ID,
+}) {
+  override get message() {
+    return `Failed to decode message ${this.messageID} in session ${this.sessionID}`
+  }
+}
+
+export class ContextSnapshotDecodeError extends Schema.TaggedErrorClass<ContextSnapshotDecodeError>()(
+  "Session.ContextSnapshotDecodeError",
+  {
+    sessionID: SessionSchema.ID,
+    details: Schema.String,
+  },
+) {
+  override get message() {
+    return `Failed to decode context snapshot for session ${this.sessionID}: ${this.details}`
+  }
+}

package/src/session/event.ts

@@ -0,0 +1,2 @@
+export * from "@neurocode-ai/schema/session-event"
+export * as SessionEvent from "@neurocode-ai/schema/session-event"

package/src/session/execution/local.ts

@@ -0,0 +1,46 @@
+import { Cause, Effect, Layer } from "effect"
+import { LocationServiceMap } from "../../location-service-map"
+import { makeGlobalNode } from "../../effect/app-node"
+import { SessionRunCoordinator } from "../run-coordinator"
+import { SessionRunner } from "../runner"
+import { SessionSchema } from "../schema"
+import { SessionStore } from "../store"
+import { SessionExecution } from "../execution"
+
+/** Current-process routing for implicit-local Locations. Future remote placement belongs here. */
+const layer = Layer.effect(
+  SessionExecution.Service,
+  Effect.gen(function* () {
+    const store = yield* SessionStore.Service
+    const locations = yield* LocationServiceMap.Service
+    const coordinator = yield* SessionRunCoordinator.make<SessionSchema.ID, SessionRunner.RunError>({
+      drain: Effect.fnUntraced(function* (sessionID: SessionSchema.ID, force) {
+        const session = yield* store.get(sessionID)
+        if (!session) return yield* Effect.die(`Session not found: ${sessionID}`)
+        return yield* SessionRunner.Service.use((runner) => runner.run({ sessionID, force })).pipe(
+          Effect.provide(locations.get(session.location)),
+          Effect.tapCause((cause) =>
+            Cause.hasInterruptsOnly(cause)
+              ? Effect.void
+              : Effect.logError("Failed to drain Session", cause).pipe(Effect.annotateLogs({ sessionID })),
+          ),
+        )
+      }),
+    })
+
+    return SessionExecution.Service.of({
+      active: coordinator.active,
+      interrupt: coordinator.interrupt,
+      resume: coordinator.run,
+      wake: coordinator.wake,
+    })
+  }),
+)
+
+export const node = makeGlobalNode({
+  service: SessionExecution.Service,
+  layer,
+  deps: [SessionStore.node, LocationServiceMap.node],
+})
+
+export * as SessionExecutionLocal from "./local"

package/src/session/execution.ts

@@ -0,0 +1,34 @@
+export * as SessionExecution from "./execution"
+
+import { Context, Effect, Layer } from "effect"
+import { LayerNode } from "../effect/layer-node"
+import { Node } from "../effect/app-node"
+import { SessionRunner } from "./runner/index"
+import { SessionSchema } from "./schema"
+
+export interface Interface {
+  /** Snapshots active execution owned by this process. */
+  readonly active: Effect.Effect<ReadonlySet<SessionSchema.ID>>
+  /** Starts execution while idle or joins the active execution. */
+  readonly resume: (sessionID: SessionSchema.ID) => Effect.Effect<void, SessionRunner.RunError>
+  /** Registers newly recorded work. Repeated wakeups may coalesce. */
+  readonly wake: (sessionID: SessionSchema.ID) => Effect.Effect<void>
+  /** Interrupt active work owned by this process. Idle interruption is a no-op. */
+  readonly interrupt: (sessionID: SessionSchema.ID) => Effect.Effect<void>
+}
+
+/** Routes execution from a Session ID to the runner owned by that Session's Location. */
+export class Service extends Context.Service<Service, Interface>()("@neurocode/v2/SessionExecution") {}
+
+export const node = LayerNode.unbound(Service, Node.tags.values.global)
+
+/** Low-level compatibility layer for callers that only need durable Session recording. */
+export const noopLayer = Layer.succeed(
+  Service,
+  Service.of({
+    active: Effect.succeed(new Set()),
+    resume: () => Effect.void,
+    wake: () => Effect.void,
+    interrupt: () => Effect.void,
+  }),
+)

package/src/session/history.ts

@@ -0,0 +1,101 @@
+import { and, asc, desc, eq, gt, gte, ne, or } from "drizzle-orm"
+import { Effect, Schema } from "effect"
+import { Database } from "../database/database"
+import { MessageDecodeError } from "./error"
+import { SessionMessage } from "./message"
+import { SessionSchema } from "./schema"
+import { SessionContextEpochTable, SessionMessageTable } from "./sql"
+
+type DatabaseService = Database.Interface["db"]
+
+const decode = Schema.decodeUnknownEffect(SessionMessage.Message)
+
+export const latestCompaction = Effect.fnUntraced(function* (db: DatabaseService, sessionID: SessionSchema.ID) {
+  return yield* db
+    .select({ seq: SessionMessageTable.seq })
+    .from(SessionMessageTable)
+    .where(and(eq(SessionMessageTable.session_id, sessionID), eq(SessionMessageTable.type, "compaction")))
+    .orderBy(desc(SessionMessageTable.seq))
+    .limit(1)
+    .get()
+    .pipe(Effect.orDie)
+})
+
+const messageRows = Effect.fnUntraced(function* (
+  db: DatabaseService,
+  sessionID: SessionSchema.ID,
+  compaction: { readonly seq: number } | undefined,
+  baselineSeq?: number,
+) {
+  const rows = yield* db
+    .select()
+    .from(SessionMessageTable)
+    .where(
+      and(
+        eq(SessionMessageTable.session_id, sessionID),
+        compaction
+          ? or(
+              gte(SessionMessageTable.seq, compaction.seq),
+              baselineSeq === undefined
+                ? undefined
+                : and(eq(SessionMessageTable.type, "system"), gt(SessionMessageTable.seq, baselineSeq)),
+            )
+          : undefined,
+        baselineSeq === undefined
+          ? undefined
+          : or(ne(SessionMessageTable.type, "system"), gt(SessionMessageTable.seq, baselineSeq)),
+      ),
+    )
+    .orderBy(asc(SessionMessageTable.seq))
+    .all()
+    .pipe(Effect.orDie)
+  return rows
+})
+
+const decodeMessageRow = (row: typeof SessionMessageTable.$inferSelect) =>
+  decode({ ...row.data, id: row.id, type: row.type }).pipe(
+    Effect.mapError(
+      () =>
+        new MessageDecodeError({
+          sessionID: SessionSchema.ID.make(row.session_id),
+          messageID: SessionMessage.ID.make(row.id),
+        }),
+    ),
+  )
+
+export const load = Effect.fn("SessionHistory.load")(function* (db: DatabaseService, sessionID: SessionSchema.ID) {
+  const [epoch, compaction] = yield* Effect.all(
+    [
+      db
+        .select({ baselineSeq: SessionContextEpochTable.baseline_seq })
+        .from(SessionContextEpochTable)
+        .where(eq(SessionContextEpochTable.session_id, sessionID))
+        .get()
+        .pipe(Effect.orDie),
+      latestCompaction(db, sessionID),
+    ],
+    { concurrency: "unbounded" },
+  )
+  return yield* Effect.forEach(yield* messageRows(db, sessionID, compaction, epoch?.baselineSeq), decodeMessageRow)
+})
+
+export const loadForRunner = Effect.fn("SessionHistory.loadForRunner")(function* (
+  db: DatabaseService,
+  sessionID: SessionSchema.ID,
+  baselineSeq: number,
+) {
+  return (yield* entriesForRunner(db, sessionID, baselineSeq)).map((entry) => entry.message)
+})
+
+export const entriesForRunner = Effect.fn("SessionHistory.entriesForRunner")(function* (
+  db: DatabaseService,
+  sessionID: SessionSchema.ID,
+  baselineSeq: number,
+) {
+  const rows = yield* messageRows(db, sessionID, yield* latestCompaction(db, sessionID), baselineSeq)
+  return yield* Effect.forEach(rows, (row) =>
+    decodeMessageRow(row).pipe(Effect.map((message) => ({ seq: row.seq, message }))),
+  )
+})
+
+export * as SessionHistory from "./history"

package/src/session/info.ts

@@ -0,0 +1,50 @@
+import { DateTime } from "effect"
+import { AgentV2 } from "../agent"
+import { Location } from "../location"
+import { ModelV2 } from "../model"
+import { ProjectV2 } from "../project"
+import { ProviderV2 } from "../provider"
+import { AbsolutePath, RelativePath } from "../schema"
+import { WorkspaceV2 } from "../workspace"
+import { SessionSchema } from "./schema"
+import { SessionTable } from "./sql"
+import { SessionMessage } from "./message"
+import { Snapshot } from "../snapshot"
+
+export function fromRow(row: typeof SessionTable.$inferSelect): SessionSchema.Info {
+  return SessionSchema.Info.make({
+    id: SessionSchema.ID.make(row.id),
+    projectID: ProjectV2.ID.make(row.project_id),
+    title: row.title,
+    parentID: row.parent_id ? SessionSchema.ID.make(row.parent_id) : undefined,
+    agent: row.agent ? AgentV2.ID.make(row.agent) : undefined,
+    model: row.model
+      ? {
+          id: ModelV2.ID.make(row.model.id),
+          providerID: ProviderV2.ID.make(row.model.providerID),
+          variant: ModelV2.VariantID.make(row.model.variant ?? "default"),
+        }
+      : undefined,
+    cost: row.cost,
+    tokens: {
+      input: row.tokens_input,
+      output: row.tokens_output,
+      reasoning: row.tokens_reasoning,
+      cache: {
+        read: row.tokens_cache_read,
+        write: row.tokens_cache_write,
+      },
+    },
+    location: Location.Ref.make({
+      directory: AbsolutePath.make(row.directory),
+      workspaceID: row.workspace_id ? WorkspaceV2.ID.make(row.workspace_id) : undefined,
+    }),
+    subpath: row.path ? RelativePath.make(row.path) : undefined,
+    revert: row.revert ? { ...row.revert, messageID: SessionMessage.ID.make(row.revert.messageID) } : undefined,
+    time: {
+      created: DateTime.makeUnsafe(row.time_created),
+      updated: DateTime.makeUnsafe(row.time_updated),
+      archived: row.time_archived ? DateTime.makeUnsafe(row.time_archived) : undefined,
+    },
+  })
+}