@nt-ai-lab/deterministic-agent-workflow-event-store 0.2.0 → 0.3.0

package/dist/platform/domain/sqlite-event-store.d.ts

@@ -1,22 +1,13 @@
-import { z } from 'zod';
+import type { RecordReflectionInput, StoredEvent, StoredReflection } from '@nt-ai-lab/deterministic-agent-workflow-engine';
 import { type SqliteDatabase } from '../infra/external-clients/sqlite/sqlite-runtime';
-declare const passthroughEventSchema: z.ZodObject<{
-    type: z.ZodString;
-    at: z.ZodString;
-}, "passthrough", z.ZodTypeAny, z.objectOutputType<{
-    type: z.ZodString;
-    at: z.ZodString;
-}, z.ZodTypeAny, "passthrough">, z.objectInputType<{
-    type: z.ZodString;
-    at: z.ZodString;
-}, z.ZodTypeAny, "passthrough">>;
-type BaseEvent = z.infer<typeof passthroughEventSchema>;
 /** @riviere-role value-object */
 export type SqliteEventStore = {
-    readonly readEvents: (sessionId: string) => readonly BaseEvent[];
-    readonly appendEvents: (sessionId: string, events: readonly BaseEvent[]) => void;
+    readonly readEvents: (sessionId: string) => readonly StoredEvent[];
+    readonly appendEvents: (sessionId: string, events: readonly StoredEvent[]) => void;
     readonly sessionExists: (sessionId: string) => boolean;
     readonly hasSessionStarted: (sessionId: string) => boolean;
+    readonly recordReflection: (sessionId: string, createdAt: string, input: RecordReflectionInput) => StoredReflection;
+    readonly listReflections: (sessionId: string) => readonly StoredReflection[];
     readonly listSessions: () => readonly string[];
     readonly db: SqliteDatabase;
 };
@@ -24,4 +15,3 @@ export type SqliteEventStore = {
 export declare function createStore(dbPath: string): SqliteEventStore;
 /** @riviere-role domain-service */
 export declare function resolveSessionId(store: SqliteEventStore, input: string): string;
-export {};

package/dist/platform/domain/sqlite-event-store.js

@@ -1,50 +1,74 @@
 import { z } from 'zod';
-import { WorkflowStateError } from '@nt-ai-lab/deterministic-agent-workflow-engine';
+import { recordReflectionInputSchema, storedReflectionSchema, stripEnvelopeKeys, WorkflowStateError, } from '@nt-ai-lab/deterministic-agent-workflow-engine';
 import { enableWalMode, openSqliteDatabase, } from '../infra/external-clients/sqlite/sqlite-runtime.js';
-const passthroughEventSchema = z.object({
-    type: z.string(),
-    at: z.string(),
-}).passthrough();
 const createTableSql = `
   CREATE TABLE IF NOT EXISTS events (
     seq INTEGER PRIMARY KEY AUTOINCREMENT,
     session_id TEXT NOT NULL,
     type TEXT NOT NULL,
     at TEXT NOT NULL,
+    state TEXT,
     payload TEXT NOT NULL
   )
 `;
-const rowWithPayloadSchema = z.array(z.object({ payload: z.string() }));
+const createReflectionsTableSql = `
+  CREATE TABLE IF NOT EXISTS reflections (
+    id INTEGER PRIMARY KEY AUTOINCREMENT,
+    session_id TEXT NOT NULL,
+    created_at TEXT NOT NULL,
+    label TEXT,
+    agent_name TEXT,
+    source_state TEXT,
+    payload_json TEXT NOT NULL
+  )
+`;
+const createReflectionsIndexSql = `
+  CREATE INDEX IF NOT EXISTS idx_reflections_session_created_at
+  ON reflections (session_id, created_at DESC, id DESC)
+`;
+const eventRowSchema = z.array(z.object({
+    type: z.string(),
+    at: z.string(),
+    state: z.string().nullable(),
+    payload: z.string(),
+}));
 const rowWithSessionIdSchema = z.array(z.object({ session_id: z.string() }));
 const countFieldSchema = z.union([z.number(), z.bigint(), z.string()]);
 const countRowSchema = z.object({ count: countFieldSchema });
+const tableInfoRowSchema = z.array(z.object({ name: z.string() }));
+const reflectionIdRowSchema = z.object({ id: countFieldSchema });
+const reflectionRowsSchema = z.array(z.object({
+    id: z.number(),
+    session_id: z.string(),
+    created_at: z.string(),
+    label: z.string().nullable(),
+    agent_name: z.string().nullable(),
+    source_state: z.string().nullable(),
+    payload_json: z.string(),
+}));
 /** @riviere-role domain-service */
 export function createStore(dbPath) {
     const db = openSqliteDatabase(dbPath);
     enableWalMode(db);
     db.exec(createTableSql);
+    db.exec(createReflectionsTableSql);
+    db.exec(createReflectionsIndexSql);
+    ensureStateColumn(db);
     return {
         db,
         readEvents(sessionId) {
-            const rawRows = db.prepare('SELECT payload FROM events WHERE session_id = ? ORDER BY seq').all(sessionId);
-            const rows = rowWithPayloadSchema.parse(rawRows);
-            return rows.map((row, index) => {
-                const parsedPayload = tryParsePayload(row.payload, index);
-                const parsedEvent = passthroughEventSchema.safeParse(parsedPayload);
-                if (!parsedEvent.success) {
-                    throw new WorkflowStateError(`Invalid event at index ${index} for session ${sessionId}: ${parsedEvent.error.message}`);
-                }
-                return parsedEvent.data;
-            });
+            const rawRows = db.prepare('SELECT type, at, state, payload FROM events WHERE session_id = ? ORDER BY seq').all(sessionId);
+            const rows = eventRowSchema.parse(rawRows);
+            return rows.map((row, index) => buildStoredEvent(row, sessionId, index));
         },
         appendEvents(sessionId, events) {
             if (events.length === 0)
                 return;
-            const insert = db.prepare('INSERT INTO events (session_id, type, at, payload) VALUES (?, ?, ?, ?)');
+            const insert = db.prepare('INSERT INTO events (session_id, type, at, state, payload) VALUES (?, ?, ?, ?, ?)');
             db.exec('BEGIN IMMEDIATE');
             try {
                 for (const event of events) {
-                    insert.run(sessionId, event.type, event.at, JSON.stringify(event));
+                    insert.run(sessionId, event.envelope.type, event.envelope.at, event.envelope.state ?? null, JSON.stringify(event.payload));
                 }
                 db.exec('COMMIT');
             }
@@ -59,6 +83,47 @@ export function createStore(dbPath) {
         hasSessionStarted(sessionId) {
             return readCount(db, "SELECT COUNT(1) AS count FROM events WHERE session_id = ? AND type = 'session-started'", sessionId) > 0;
         },
+        recordReflection(sessionId, createdAt, input) {
+            const parsedInput = recordReflectionInputSchema.parse(input);
+            const insert = db.prepare('INSERT INTO reflections (session_id, created_at, label, agent_name, source_state, payload_json) VALUES (?, ?, ?, ?, ?, ?)');
+            db.exec('BEGIN IMMEDIATE');
+            try {
+                insert.run(sessionId, createdAt, parsedInput.label ?? null, parsedInput.agentName ?? null, parsedInput.sourceState ?? null, JSON.stringify(parsedInput.reflection));
+                const rawId = db.prepare('SELECT last_insert_rowid() AS id').get();
+                const parsedId = reflectionIdRowSchema.parse(rawId);
+                const id = Number(parsedId.id);
+                db.exec('COMMIT');
+                return storedReflectionSchema.parse({
+                    id,
+                    sessionId,
+                    createdAt,
+                    ...(parsedInput.label === undefined ? {} : { label: parsedInput.label }),
+                    ...(parsedInput.agentName === undefined ? {} : { agentName: parsedInput.agentName }),
+                    ...(parsedInput.sourceState === undefined ? {} : { sourceState: parsedInput.sourceState }),
+                    reflection: parsedInput.reflection,
+                });
+            }
+            catch (error) {
+                db.exec('ROLLBACK');
+                throw error;
+            }
+        },
+        listReflections(sessionId) {
+            const rawRows = db.prepare('SELECT id, session_id, created_at, label, agent_name, source_state, payload_json FROM reflections WHERE session_id = ? ORDER BY created_at DESC, id DESC').all(sessionId);
+            const rows = reflectionRowsSchema.parse(rawRows);
+            return rows.map((row) => {
+                const reflectionPayload = JSON.parse(row.payload_json);
+                return storedReflectionSchema.parse({
+                    id: row.id,
+                    sessionId: row.session_id,
+                    createdAt: row.created_at,
+                    ...(row.label === null ? {} : { label: row.label }),
+                    ...(row.agent_name === null ? {} : { agentName: row.agent_name }),
+                    ...(row.source_state === null ? {} : { sourceState: row.source_state }),
+                    reflection: reflectionPayload,
+                });
+            });
+        },
         listSessions() {
             const rawRows = db.prepare('SELECT session_id FROM events GROUP BY session_id ORDER BY MIN(seq)').all();
             return rowWithSessionIdSchema.parse(rawRows).map((row) => row.session_id);
@@ -101,3 +166,33 @@ function tryParsePayload(payload, index) {
         throw new WorkflowStateError(`Cannot parse event payload at index ${index}: ${String(cause)}`);
     }
 }
+function ensureStateColumn(db) {
+    const rawColumns = db.prepare('PRAGMA table_info(events)').all();
+    const columns = tableInfoRowSchema.parse(rawColumns);
+    if (columns.some((column) => column.name === 'state'))
+        return;
+    db.exec('ALTER TABLE events ADD COLUMN state TEXT');
+}
+/**
+ * Dual-read adapter. Modern rows carry only domain fields in `payload` JSON
+ * (envelope in columns). Legacy rows have `type`/`at` duplicated inside the
+ * payload JSON and no `state` column value. Either way, normalize to
+ * `StoredEvent` with undefined state for legacy rows.
+ */
+function buildStoredEvent(row, sessionId, index) {
+    const parsedPayload = tryParsePayload(row.payload, index);
+    if (!isRecord(parsedPayload)) {
+        throw new WorkflowStateError(`Invalid event payload at index ${index} for session ${sessionId}: expected object`);
+    }
+    return {
+        envelope: {
+            type: row.type,
+            at: row.at,
+            state: row.state ?? undefined,
+        },
+        payload: stripEnvelopeKeys(parsedPayload),
+    };
+}
+function isRecord(value) {
+    return typeof value === 'object' && value !== null;
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@nt-ai-lab/deterministic-agent-workflow-event-store",
-  "version": "0.2.0",
+  "version": "0.3.0",
   "private": false,
   "type": "module",
   "exports": {
@@ -11,8 +11,8 @@
     "dist"
   ],
   "dependencies": {
-    "@nt-ai-lab/deterministic-agent-workflow-engine": "0.2.0",
-    "zod": "^3.25.76"
+    "zod": "^3.25.76",
+    "@nt-ai-lab/deterministic-agent-workflow-engine": "0.3.0"
   },
   "publishConfig": {
     "access": "public"