@neurocode-ai/core 1.18.8

package/src/session/input.ts

@@ -0,0 +1,288 @@
+export * as SessionInput from "./input"
+
+import { and, asc, eq, isNull, lte } from "drizzle-orm"
+import { DateTime, Effect, Schema } from "effect"
+import { Admitted, Delivery } from "@neurocode-ai/schema/session-input"
+import type { Database } from "../database/database"
+import type { EventV2 } from "../event"
+import { SessionEvent } from "./event"
+import { SessionMessage } from "./message"
+import { Prompt } from "./prompt"
+import { SessionSchema } from "./schema"
+import { SessionInputTable, SessionMessageTable } from "./sql"
+
+type DatabaseService = Database.Interface["db"]
+
+export { Admitted, Delivery }
+
+const decodePrompt = Schema.decodeUnknownSync(Prompt)
+const encodePrompt = Schema.encodeSync(Prompt)
+
+const fromRow = (row: typeof SessionInputTable.$inferSelect): Admitted =>
+  Admitted.make({
+    admittedSeq: row.admitted_seq,
+    id: SessionMessage.ID.make(row.id),
+    sessionID: SessionSchema.ID.make(row.session_id),
+    prompt: decodePrompt(row.prompt),
+    delivery: row.delivery,
+    timeCreated: DateTime.makeUnsafe(row.time_created),
+    ...(row.promoted_seq === null ? {} : { promotedSeq: row.promoted_seq }),
+  })
+
+export const find = Effect.fn("SessionInput.find")(function* (db: DatabaseService, id: SessionMessage.ID) {
+  const row = yield* db.select().from(SessionInputTable).where(eq(SessionInputTable.id, id)).get().pipe(Effect.orDie)
+  return row === undefined ? undefined : fromRow(row)
+})
+
+export class LifecycleConflict extends Schema.TaggedErrorClass<LifecycleConflict>()("SessionInput.LifecycleConflict", {
+  id: SessionMessage.ID,
+}) {}
+
+export const admit = Effect.fn("SessionInput.admit")(function* (
+  db: DatabaseService,
+  events: EventV2.Interface,
+  input: {
+    readonly id: SessionMessage.ID
+    readonly sessionID: SessionSchema.ID
+    readonly prompt: Prompt
+    readonly delivery: Delivery
+  },
+) {
+  const existing = yield* find(db, input.id)
+  if (existing !== undefined) return existing
+  const timestamp = yield* DateTime.now
+  return yield* events
+    .publish(SessionEvent.PromptAdmitted, {
+      messageID: input.id,
+      sessionID: input.sessionID,
+      timestamp,
+      prompt: input.prompt,
+      delivery: input.delivery,
+    })
+    .pipe(
+      Effect.flatMap((event) =>
+        event.durable === undefined
+          ? Effect.die("Prompt admission event is missing aggregate sequence")
+          : Effect.succeed(
+              Admitted.make({
+                admittedSeq: event.durable.seq,
+                id: input.id,
+                sessionID: input.sessionID,
+                prompt: input.prompt,
+                delivery: input.delivery,
+                timeCreated: timestamp,
+              }),
+            ),
+      ),
+      Effect.catchDefect((defect) =>
+        find(db, input.id).pipe(Effect.flatMap((stored) => (stored ? Effect.succeed(stored) : Effect.die(defect)))),
+      ),
+    )
+})
+
+export const projectAdmitted = Effect.fn("SessionInput.projectAdmitted")(function* (
+  db: DatabaseService,
+  input: {
+    readonly admittedSeq: number
+    readonly id: SessionMessage.ID
+    readonly sessionID: SessionSchema.ID
+    readonly prompt: Prompt
+    readonly delivery: Delivery
+    readonly timeCreated: DateTime.Utc
+  },
+) {
+  const message = yield* db
+    .select({ id: SessionMessageTable.id })
+    .from(SessionMessageTable)
+    .where(eq(SessionMessageTable.id, input.id))
+    .get()
+    .pipe(Effect.orDie)
+  if (message !== undefined) return yield* Effect.die(new LifecycleConflict({ id: input.id }))
+  const stored = yield* db
+    .insert(SessionInputTable)
+    .values({
+      id: input.id,
+      session_id: input.sessionID,
+      admitted_seq: input.admittedSeq,
+      prompt: encodePrompt(input.prompt),
+      delivery: input.delivery,
+      time_created: DateTime.toEpochMillis(input.timeCreated),
+    })
+    .onConflictDoNothing()
+    .returning({ id: SessionInputTable.id })
+    .get()
+    .pipe(Effect.orDie)
+  if (!stored) return yield* Effect.die(new LifecycleConflict({ id: input.id }))
+})
+
+export const projectPrompted = Effect.fn("SessionInput.projectPrompted")(function* (
+  db: DatabaseService,
+  input: {
+    readonly id: SessionMessage.ID
+    readonly sessionID: SessionSchema.ID
+    readonly prompt: Prompt
+    readonly delivery: Delivery
+    readonly timeCreated: DateTime.Utc
+    readonly promotedSeq: number
+  },
+) {
+  const updated = yield* db
+    .update(SessionInputTable)
+    .set({ promoted_seq: input.promotedSeq })
+    .where(
+      and(
+        eq(SessionInputTable.id, input.id),
+        eq(SessionInputTable.session_id, input.sessionID),
+        isNull(SessionInputTable.promoted_seq),
+      ),
+    )
+    .returning()
+    .get()
+    .pipe(Effect.orDie)
+  if (updated) {
+    const stored = fromRow(updated)
+    if (!matchesProjection(stored, input)) return yield* Effect.die(new LifecycleConflict({ id: input.id }))
+    return
+  }
+
+  const stored = yield* find(db, input.id)
+  if (stored) {
+    if (!matchesProjection(stored, input) || stored.promotedSeq !== input.promotedSeq)
+      return yield* Effect.die(new LifecycleConflict({ id: input.id }))
+    return
+  }
+
+  yield* db
+    .insert(SessionInputTable)
+    .values({
+      id: input.id,
+      session_id: input.sessionID,
+      prompt: encodePrompt(input.prompt),
+      delivery: input.delivery,
+      admitted_seq: input.promotedSeq,
+      promoted_seq: input.promotedSeq,
+      time_created: DateTime.toEpochMillis(input.timeCreated),
+    })
+    .run()
+    .pipe(Effect.orDie)
+})
+
+export const hasPending = Effect.fn("SessionInput.hasPending")(function* (
+  db: DatabaseService,
+  sessionID: SessionSchema.ID,
+  delivery: Delivery,
+) {
+  const row = yield* db
+    .select({ id: SessionInputTable.id })
+    .from(SessionInputTable)
+    .where(
+      and(
+        eq(SessionInputTable.session_id, sessionID),
+        isNull(SessionInputTable.promoted_seq),
+        eq(SessionInputTable.delivery, delivery),
+      ),
+    )
+    .limit(1)
+    .get()
+    .pipe(Effect.orDie)
+  return row !== undefined
+})
+
+export const equivalent = (
+  input: Admitted,
+  expected: {
+    readonly sessionID: SessionSchema.ID
+    readonly prompt: Prompt
+    readonly delivery: Delivery
+  },
+) => input.delivery === expected.delivery && matchesPrompt(input, expected)
+
+const matchesPrompt = (input: Admitted, expected: { readonly sessionID: SessionSchema.ID; readonly prompt: Prompt }) =>
+  input.sessionID === expected.sessionID &&
+  JSON.stringify(encodePrompt(input.prompt)) === JSON.stringify(encodePrompt(expected.prompt))
+
+const matchesProjection = (
+  input: Admitted,
+  expected: {
+    readonly sessionID: SessionSchema.ID
+    readonly prompt: Prompt
+    readonly delivery: Delivery
+    readonly timeCreated: DateTime.Utc
+  },
+) =>
+  equivalent(input, expected) &&
+  DateTime.toEpochMillis(input.timeCreated) === DateTime.toEpochMillis(expected.timeCreated)
+
+const publish = Effect.fn("SessionInput.publish")(function* (
+  db: DatabaseService,
+  events: EventV2.Interface,
+  sessionID: SessionSchema.ID,
+  rows: ReadonlyArray<typeof SessionInputTable.$inferSelect>,
+) {
+  for (const row of rows) {
+    const id = SessionMessage.ID.make(row.id)
+    yield* events
+      .publish(SessionEvent.Prompted, {
+        sessionID,
+        timestamp: DateTime.makeUnsafe(row.time_created),
+        messageID: id,
+        prompt: decodePrompt(row.prompt),
+        delivery: row.delivery,
+      })
+      .pipe(
+        Effect.catchDefect((defect) =>
+          defect instanceof LifecycleConflict
+            ? find(db, id).pipe(
+                Effect.flatMap((stored) => (stored?.promotedSeq === undefined ? Effect.die(defect) : Effect.void)),
+              )
+            : Effect.die(defect),
+        ),
+      )
+  }
+  return rows.length
+})
+
+export const promoteSteers = Effect.fn("SessionInput.promoteSteers")(function* (
+  db: DatabaseService,
+  events: EventV2.Interface,
+  sessionID: SessionSchema.ID,
+  cutoff: number,
+) {
+  const rows = yield* db
+    .select()
+    .from(SessionInputTable)
+    .where(
+      and(
+        eq(SessionInputTable.session_id, sessionID),
+        isNull(SessionInputTable.promoted_seq),
+        eq(SessionInputTable.delivery, "steer"),
+        lte(SessionInputTable.admitted_seq, cutoff),
+      ),
+    )
+    .orderBy(asc(SessionInputTable.admitted_seq))
+    .all()
+    .pipe(Effect.orDie)
+  return yield* publish(db, events, sessionID, rows)
+})
+
+export const promoteNextQueued = Effect.fn("SessionInput.promoteNextQueued")(function* (
+  db: DatabaseService,
+  events: EventV2.Interface,
+  sessionID: SessionSchema.ID,
+) {
+  const row = yield* db
+    .select()
+    .from(SessionInputTable)
+    .where(
+      and(
+        eq(SessionInputTable.session_id, sessionID),
+        isNull(SessionInputTable.promoted_seq),
+        eq(SessionInputTable.delivery, "queue"),
+      ),
+    )
+    .orderBy(asc(SessionInputTable.admitted_seq))
+    .limit(1)
+    .get()
+    .pipe(Effect.orDie)
+  return row === undefined ? false : yield* publish(db, events, sessionID, [row]).pipe(Effect.as(true))
+})

package/src/session/message-updater.ts

@@ -0,0 +1,397 @@
+import { castDraft, produce, type WritableDraft } from "immer"
+import { Effect } from "effect"
+import { SessionEvent } from "./event"
+import { SessionMessage } from "./message"
+
+export type MemoryState = {
+  messages: SessionMessage.Message[]
+}
+
+export interface Adapter {
+  readonly getCurrentAssistant: () => Effect.Effect<SessionMessage.Assistant | undefined>
+  readonly getAssistant: (messageID: SessionMessage.ID) => Effect.Effect<SessionMessage.Assistant | undefined>
+  readonly getCurrentShell: (callID: string) => Effect.Effect<SessionMessage.Shell | undefined>
+  readonly updateAssistant: (assistant: SessionMessage.Assistant) => Effect.Effect<void>
+  readonly updateShell: (shell: SessionMessage.Shell) => Effect.Effect<void>
+  readonly appendMessage: (message: SessionMessage.Message) => Effect.Effect<void>
+}
+
+export function memory(state: MemoryState): Adapter {
+  const assistantIndex = (messageID: SessionMessage.ID) =>
+    state.messages.findLastIndex((message) => message.id === messageID)
+  // A newer turn supersedes stale incomplete rows; never resume an older assistant projection.
+  const latestAssistantIndex = () => state.messages.findLastIndex((message) => message.type === "assistant")
+  const activeShellIndex = (callID: string) =>
+    state.messages.findLastIndex((message) => message.type === "shell" && message.callID === callID)
+
+  return {
+    getCurrentAssistant() {
+      return Effect.sync(() => {
+        const index = latestAssistantIndex()
+        if (index < 0) return
+        const assistant = state.messages[index]
+        return assistant?.type === "assistant" && !assistant.time.completed ? assistant : undefined
+      })
+    },
+    getAssistant(messageID) {
+      return Effect.sync(() => {
+        const index = assistantIndex(messageID)
+        if (index < 0) return
+        const assistant = state.messages[index]
+        return assistant?.type === "assistant" ? assistant : undefined
+      })
+    },
+    getCurrentShell(callID) {
+      return Effect.sync(() => {
+        const index = activeShellIndex(callID)
+        if (index < 0) return
+        const shell = state.messages[index]
+        return shell?.type === "shell" ? shell : undefined
+      })
+    },
+    updateAssistant(assistant) {
+      return Effect.sync(() => {
+        const index = assistantIndex(assistant.id)
+        if (index < 0) return
+        const current = state.messages[index]
+        if (current?.type !== "assistant") return
+        state.messages[index] = assistant
+      })
+    },
+    updateShell(shell) {
+      return Effect.sync(() => {
+        const index = activeShellIndex(shell.callID)
+        if (index < 0) return
+        const current = state.messages[index]
+        if (current?.type !== "shell") return
+        state.messages[index] = shell
+      })
+    },
+    appendMessage(message) {
+      return Effect.sync(() => {
+        state.messages.push(message)
+      })
+    },
+  }
+}
+
+export function update(adapter: Adapter, event: SessionEvent.Event) {
+  type DraftAssistant = WritableDraft<SessionMessage.Assistant>
+  type DraftTool = WritableDraft<SessionMessage.AssistantTool>
+  type DraftText = WritableDraft<SessionMessage.AssistantText>
+  type DraftReasoning = WritableDraft<SessionMessage.AssistantReasoning>
+
+  const latestTool = (assistant: DraftAssistant | undefined, callID?: string) =>
+    assistant?.content.findLast(
+      (item): item is DraftTool => item.type === "tool" && (callID === undefined || item.id === callID),
+    )
+
+  const latestText = (assistant: DraftAssistant | undefined, textID: string) =>
+    assistant?.content.findLast((item): item is DraftText => item.type === "text" && item.id === textID)
+
+  const latestReasoning = (assistant: DraftAssistant | undefined, reasoningID: string) =>
+    assistant?.content.findLast((item): item is DraftReasoning => item.type === "reasoning" && item.id === reasoningID)
+
+  const updateOwnedAssistant = (messageID: SessionMessage.ID, recipe: (draft: DraftAssistant) => void) =>
+    Effect.gen(function* () {
+      const assistant = yield* adapter.getAssistant(messageID)
+      if (assistant) yield* adapter.updateAssistant(produce(assistant, recipe))
+    })
+
+  return Effect.gen(function* () {
+    yield* SessionEvent.All.match(event, {
+      "session.next.agent.switched": (event) => {
+        return adapter.appendMessage(
+          SessionMessage.AgentSwitched.make({
+            id: event.data.messageID,
+            type: "agent-switched",
+            metadata: event.metadata,
+            agent: event.data.agent,
+            time: { created: event.data.timestamp },
+          }),
+        )
+      },
+      "session.next.model.switched": (event) => {
+        return adapter.appendMessage(
+          SessionMessage.ModelSwitched.make({
+            id: event.data.messageID,
+            type: "model-switched",
+            metadata: event.metadata,
+            model: event.data.model,
+            time: { created: event.data.timestamp },
+          }),
+        )
+      },
+      "session.next.moved": () => Effect.void,
+      "session.next.prompted": (event) => {
+        return adapter.appendMessage(
+          SessionMessage.User.make({
+            id: event.data.messageID,
+            type: "user",
+            metadata: event.metadata,
+            text: event.data.prompt.text,
+            files: event.data.prompt.files,
+            agents: event.data.prompt.agents,
+            time: { created: event.data.timestamp },
+          }),
+        )
+      },
+      "session.next.prompt.admitted": () => Effect.void,
+      "session.next.context.updated": (event) =>
+        adapter.appendMessage(
+          SessionMessage.System.make({
+            id: event.data.messageID,
+            type: "system",
+            text: event.data.text,
+            time: { created: event.data.timestamp },
+          }),
+        ),
+      "session.next.synthetic": (event) => {
+        return adapter.appendMessage(
+          SessionMessage.Synthetic.make({
+            sessionID: event.data.sessionID,
+            text: event.data.text,
+            id: event.data.messageID,
+            type: "synthetic",
+            time: { created: event.data.timestamp },
+          }),
+        )
+      },
+      "session.next.shell.started": (event) => {
+        return adapter.appendMessage(
+          SessionMessage.Shell.make({
+            id: event.data.messageID,
+            type: "shell",
+            metadata: event.metadata,
+            callID: event.data.callID,
+            command: event.data.command,
+            output: "",
+            time: { created: event.data.timestamp },
+          }),
+        )
+      },
+      "session.next.shell.ended": (event) => {
+        return Effect.gen(function* () {
+          const currentShell = yield* adapter.getCurrentShell(event.data.callID)
+          if (currentShell) {
+            yield* adapter.updateShell(
+              produce(currentShell, (draft) => {
+                draft.output = event.data.output
+                draft.time.completed = event.data.timestamp
+              }),
+            )
+          }
+        })
+      },
+      "session.next.step.started": (event) => {
+        return Effect.gen(function* () {
+          const currentAssistant = yield* adapter.getCurrentAssistant()
+          if (currentAssistant) {
+            yield* adapter.updateAssistant(
+              produce(currentAssistant, (draft) => {
+                draft.time.completed = event.data.timestamp
+              }),
+            )
+          }
+          yield* adapter.appendMessage(
+            SessionMessage.Assistant.make({
+              id: event.data.assistantMessageID,
+              type: "assistant",
+              agent: event.data.agent,
+              model: event.data.model,
+              time: { created: event.data.timestamp },
+              content: [],
+              snapshot: event.data.snapshot ? { start: event.data.snapshot } : undefined,
+            }),
+          )
+        })
+      },
+      "session.next.step.ended": (event) => {
+        return updateOwnedAssistant(event.data.assistantMessageID, (draft) => {
+          draft.time.completed = event.data.timestamp
+          draft.finish = event.data.finish
+          draft.cost = event.data.cost
+          draft.tokens = event.data.tokens
+          if (event.data.snapshot || event.data.files)
+            draft.snapshot = {
+              ...draft.snapshot,
+              end: event.data.snapshot,
+              files: event.data.files ? Array.from(event.data.files) : undefined,
+            }
+        })
+      },
+      "session.next.step.failed": (event) => {
+        return updateOwnedAssistant(event.data.assistantMessageID, (draft) => {
+          draft.time.completed = event.data.timestamp
+          draft.finish = "error"
+          draft.error = event.data.error
+        })
+      },
+      "session.next.text.started": (event) => {
+        return updateOwnedAssistant(event.data.assistantMessageID, (draft) => {
+          draft.content.push(
+            castDraft(SessionMessage.AssistantText.make({ type: "text", id: event.data.textID, text: "" })),
+          )
+        })
+      },
+      "session.next.text.delta": (event) => {
+        return updateOwnedAssistant(event.data.assistantMessageID, (draft) => {
+          const match = latestText(draft, event.data.textID)
+          if (match) match.text += event.data.delta
+        })
+      },
+      "session.next.text.ended": (event) => {
+        return updateOwnedAssistant(event.data.assistantMessageID, (draft) => {
+          const match = latestText(draft, event.data.textID)
+          if (match) match.text = event.data.text
+        })
+      },
+      "session.next.tool.input.started": (event) => {
+        return updateOwnedAssistant(event.data.assistantMessageID, (draft) => {
+          draft.content.push(
+            castDraft(
+              SessionMessage.AssistantTool.make({
+                type: "tool",
+                id: event.data.callID,
+                name: event.data.name,
+                time: { created: event.data.timestamp },
+                state: SessionMessage.ToolStatePending.make({ status: "pending", input: "" }),
+              }),
+            ),
+          )
+        })
+      },
+      "session.next.tool.input.delta": () => Effect.void,
+      "session.next.tool.input.ended": (event) => {
+        return updateOwnedAssistant(event.data.assistantMessageID, (draft) => {
+          const match = latestTool(draft, event.data.callID)
+          if (match && match.state.status === "pending") match.state.input = event.data.text
+        })
+      },
+      "session.next.tool.called": (event) => {
+        return updateOwnedAssistant(event.data.assistantMessageID, (draft) => {
+          const match = latestTool(draft, event.data.callID)
+          if (match) {
+            match.provider = event.data.provider
+            match.time.ran = event.data.timestamp
+            match.state = castDraft(
+              SessionMessage.ToolStateRunning.make({
+                status: "running",
+                input: event.data.input,
+                structured: {},
+                content: [],
+              }),
+            )
+          }
+        })
+      },
+      "session.next.tool.progress": (event) => {
+        return updateOwnedAssistant(event.data.assistantMessageID, (draft) => {
+          const match = latestTool(draft, event.data.callID)
+          if (match && match.state.status === "running") {
+            match.state.structured = event.data.structured
+            match.state.content = [...event.data.content]
+          }
+        })
+      },
+      "session.next.tool.success": (event) => {
+        return updateOwnedAssistant(event.data.assistantMessageID, (draft) => {
+          const match = latestTool(draft, event.data.callID)
+          if (match && match.state.status === "running") {
+            match.provider = {
+              executed: event.data.provider.executed || match.provider?.executed === true,
+              metadata: match.provider?.metadata,
+              resultMetadata: event.data.provider.metadata,
+            }
+            match.time.completed = event.data.timestamp
+            match.state = castDraft(
+              SessionMessage.ToolStateCompleted.make({
+                status: "completed",
+                input: match.state.input,
+                structured: event.data.structured,
+                content: [...event.data.content],
+                outputPaths: event.data.outputPaths ? [...event.data.outputPaths] : [],
+                result: event.data.result,
+              }),
+            )
+          }
+        })
+      },
+      "session.next.tool.failed": (event) => {
+        return updateOwnedAssistant(event.data.assistantMessageID, (draft) => {
+          const match = latestTool(draft, event.data.callID)
+          if (match && (match.state.status === "pending" || match.state.status === "running")) {
+            match.provider = {
+              executed: event.data.provider.executed || match.provider?.executed === true,
+              metadata: match.provider?.metadata,
+              resultMetadata: event.data.provider.metadata,
+            }
+            match.time.completed = event.data.timestamp
+            match.state = castDraft(
+              SessionMessage.ToolStateError.make({
+                status: "error",
+                error: event.data.error,
+                input: typeof match.state.input === "string" ? {} : match.state.input,
+                structured: match.state.status === "running" ? match.state.structured : {},
+                content: match.state.status === "running" ? match.state.content : [],
+                result: event.data.result,
+              }),
+            )
+          }
+        })
+      },
+      "session.next.reasoning.started": (event) => {
+        return updateOwnedAssistant(event.data.assistantMessageID, (draft) => {
+          draft.content.push(
+            castDraft(
+              SessionMessage.AssistantReasoning.make({
+                type: "reasoning",
+                id: event.data.reasoningID,
+                text: "",
+                providerMetadata: event.data.providerMetadata,
+                time: { created: event.data.timestamp },
+              }),
+            ),
+          )
+        })
+      },
+      "session.next.reasoning.delta": (event) => {
+        return updateOwnedAssistant(event.data.assistantMessageID, (draft) => {
+          const match = latestReasoning(draft, event.data.reasoningID)
+          if (match) match.text += event.data.delta
+        })
+      },
+      "session.next.reasoning.ended": (event) => {
+        return updateOwnedAssistant(event.data.assistantMessageID, (draft) => {
+          const match = latestReasoning(draft, event.data.reasoningID)
+          if (match) {
+            match.text = event.data.text
+            match.time = { created: match.time?.created ?? event.data.timestamp, completed: event.data.timestamp }
+            if (event.data.providerMetadata !== undefined) match.providerMetadata = event.data.providerMetadata
+          }
+        })
+      },
+      "session.next.retried": () => Effect.void,
+      "session.next.compaction.started": () => Effect.void,
+      "session.next.compaction.delta": () => Effect.void,
+      "session.next.compaction.ended": (event) => {
+        return adapter.appendMessage(
+          SessionMessage.Compaction.make({
+            id: event.data.messageID,
+            type: "compaction",
+            metadata: event.metadata,
+            reason: event.data.reason,
+            summary: event.data.text,
+            recent: event.data.recent,
+            time: { created: event.data.timestamp },
+          }),
+        )
+      },
+      "session.next.revert.staged": () => Effect.void,
+      "session.next.revert.cleared": () => Effect.void,
+      "session.next.revert.committed": () => Effect.void,
+    })
+  })
+}
+
+export * as SessionMessageUpdater from "./message-updater"

package/src/session/message.ts

@@ -0,0 +1,2 @@
+export * as SessionMessage from "./message"
+export * from "@neurocode-ai/schema/session-message"