@effect-agent/storage-sqlite 0.1.0-beta.24 → 0.1.0-beta.25

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@effect-agent/storage-sqlite",
-  "version": "0.1.0-beta.24",
+  "version": "0.1.0-beta.25",
   "exports": {
     ".": {
       "types": "./dist/index.d.mts",
@@ -8,7 +8,7 @@
     }
   },
   "dependencies": {
-    "@effect-agent/session": "0.1.0-beta.24",
+    "@effect-agent/session": "0.1.0-beta.25",
     "@effect/platform-node": "4.0.0-rc.110",
     "@effect/sql-sqlite-node": "4.0.0-rc.110",
     "effect": "4.0.0-rc.110"

package/src/sqlite-conversation-store.ts

@@ -43,12 +43,12 @@ import {
 } from "effect";
 import * as SqlClientService from "effect/unstable/sql/SqlClient";
 
+import type { SqliteStorageCompatibilityError } from "./errors.ts";
 import {
   SqliteAppendConflict,
   SqliteCheckpointConflict,
   SqliteFenceRejected,
   type SqliteStorageFailpointLocation,
-  SqliteStorageCompatibilityError,
   SqliteStorageCorruptionError,
   SqliteStorageError,
 } from "./errors.ts";
@@ -93,6 +93,9 @@ const OffsetText = Schema.String.check(Schema.isMaxLength(4 * 1024));
 const SQLITE_OFFSET_PREFIX = "effect-agent-sqlite@1:";
 const ZERO_CANONICAL_SEQUENCE = Schema.decodeSync(CanonicalSequence)(0);
 const isDigest = Schema.is(Digest);
+const isSqliteFenceRejected = Schema.is(SqliteFenceRejected);
+const isSqliteAppendConflict = Schema.is(SqliteAppendConflict);
+const isSqliteCheckpointConflict = Schema.is(SqliteCheckpointConflict);
 
 const storeError = (operation: string, error: { readonly message: string }) =>
   ConversationStoreError.make({
@@ -542,10 +545,10 @@ const makeServices = Effect.fn("SqliteConversationStore.makeServices")(function*
     yield* hitFailpoint("append:before");
     const result = yield* journal.append(rawRequest).pipe(
       Effect.mapError((error) => {
-        if (error instanceof SqliteFenceRejected) {
+        if (isSqliteFenceRejected(error)) {
           return mapFence(validated.conversationId, error);
         }
-        if (error instanceof SqliteAppendConflict) {
+        if (isSqliteAppendConflict(error)) {
           return error.actualTailSequence !== undefined && isDigest(error.actualTailDigest)
             ? AppendConflict.make({
                 conversationId: validated.conversationId,
@@ -713,7 +716,7 @@ const makeServices = Effect.fn("SqliteConversationStore.makeServices")(function*
     yield* hitFailpoint("save-checkpoint:before");
     yield* journal.saveCheckpoint(raw).pipe(
       Effect.mapError((error) =>
-        error instanceof SqliteCheckpointConflict
+        isSqliteCheckpointConflict(error)
           ? CheckpointRejected.make({
               conversationId: validated.checkpoint.conversationId,
               reason: "digest-mismatch",
@@ -823,19 +826,21 @@ export const storageFailpointLayer = (
  */
 export const layer = (
   options: SqliteStorageOptions,
-): Layer.Layer<ConversationStore, SqliteStorageInitializationError> => {
-  const sqlLayer = SqliteClient.layer({ filename: options.filename });
-  return conversationStoreLayer.pipe(
-    Layer.provide(
-      Layer.mergeAll(
-        storageConfigLayer(options),
-        storageFailpointLayer(options),
-        sqlLayer,
-        NodeCrypto.layer,
+): Layer.Layer<ConversationStore, SqliteStorageInitializationError> =>
+  Layer.unwrap(
+    Effect.map(SqliteStorageConfig, (config) =>
+      conversationStoreLayer.pipe(
+        Layer.provide(
+          Layer.mergeAll(
+            Layer.succeed(SqliteStorageConfig)(config),
+            storageFailpointLayer(options),
+            SqliteClient.layer({ filename: options.filename }),
+            NodeCrypto.layer,
+          ),
+        ),
       ),
     ),
-  );
-};
+  ).pipe(Layer.provide(storageConfigLayer(options)));
 
 /** Create an adapter-owned resumable observation offset for a known canonical sequence. */
 export const observationOffsetAt = makeOffset;

package/src/sqlite-ledger.ts

@@ -105,6 +105,11 @@ const BoundedTimestamp = Schema.NonEmptyString.check(Schema.isMaxLength(128));
 
 const SCAN_PAGE_SIZE = 256;
 const EPOCH_ZERO = Schema.decodeSync(ProducerEpoch)(0);
+const RESUME_IMMEDIATELY: SuspensionOutcome = "resume-immediately";
+const SUSPENDED: SuspensionOutcome = "suspended";
+const NOT_WAITING: ChildSettledOutcome = "not-waiting";
+const STILL_WAITING: ChildSettledOutcome = "still-waiting";
+const WOKEN: ChildSettledOutcome = "woken";
 
 class SubmissionRow extends Schema.Class<SubmissionRow>("SubmissionRow")({
   submission_id: BoundedIdentifier,
@@ -276,6 +281,11 @@ const decodeChildReservationSnapshotUnknown = Schema.decodeUnknownEffect(
   ChildBudgetReservationSnapshot,
 );
 const decodeChildAttachmentSnapshot = Schema.decodeUnknownEffect(ChildAttachmentSnapshot);
+const equivalentPersistedJson = Schema.toEquivalence(PersistedJson);
+const equivalentUnknownResolution = Schema.toEquivalence(UnknownResolution);
+const isSqliteTransactionFailure = Schema.is(
+  Schema.Union([SqliteStorageError, SqliteWriteContention]),
+);
 
 /** Wrap an adapter-internal failure into the port's LedgerError without erasing its tag. */
 const internalFailure =
@@ -343,9 +353,7 @@ const makeServices = Effect.fn("SqliteSubmissionLedger.makeServices")(function*
       .withWriteTransaction(operation)(effect)
       .pipe(
         Effect.mapError((error) =>
-          error instanceof SqliteStorageError || error instanceof SqliteWriteContention
-            ? internalFailure(operation)(error)
-            : error,
+          isSqliteTransactionFailure(error) ? internalFailure(operation)(error) : error,
         ),
       );
 
@@ -1749,7 +1757,7 @@ const makeServices = Effect.fn("SqliteSubmissionLedger.makeServices")(function*
             }).pipe(Effect.mapError(internalFailure(operation))),
           );
         }
-        return claimed as ReadonlyArray<JoiningClaim>;
+        return claimed;
       }),
     );
     yield* hitFailpoint("ledger:claim-joining:after", operation);
@@ -1882,7 +1890,7 @@ const makeServices = Effect.fn("SqliteSubmissionLedger.makeServices")(function*
           const decisions = yield* readApprovalDecisions(operation, validated.submissionId);
           const decided = new Set(decisions.map((row) => row.tool_call_id));
           if (validated.reason.toolCallIds.every((toolCallId) => decided.has(toolCallId))) {
-            return "resume-immediately" as SuspensionOutcome;
+            return RESUME_IMMEDIATELY;
           }
         } else {
           let allSettled = true;
@@ -1894,7 +1902,7 @@ const makeServices = Effect.fn("SqliteSubmissionLedger.makeServices")(function*
             }
           }
           if (allSettled) {
-            return "resume-immediately" as SuspensionOutcome;
+            return RESUME_IMMEDIATELY;
           }
         }
         const now = yield* currentInstant;
@@ -1912,7 +1920,7 @@ const makeServices = Effect.fn("SqliteSubmissionLedger.makeServices")(function*
           DELETE FROM effect_agent_submission_ownership
           WHERE submission_id = ${validated.submissionId}
         `.pipe(Effect.mapError(sqlFailure(operation)));
-        return "suspended" as SuspensionOutcome;
+        return SUSPENDED;
       }),
     );
     yield* hitFailpoint("ledger:suspend:after", operation);
@@ -2118,17 +2126,24 @@ const makeServices = Effect.fn("SqliteSubmissionLedger.makeServices")(function*
         }
         const resolutions = yield* readUnknownResolutions(operation, validated.submissionId);
         const existing = resolutions.find((row) => row.tool_call_id === validated.toolCallId);
-        if (existing !== undefined && existing.resolution_json !== resolutionJson) {
+        const existingIntent =
+          existing === undefined
+            ? undefined
+            : yield* unknownResolutionIntentFromRow(operation, existing);
+        if (
+          existingIntent !== undefined &&
+          !equivalentUnknownResolution(existingIntent.resolution, validated.resolution)
+        ) {
           return yield* UnknownResolutionConflict.make({
             submissionId: validated.submissionId,
             toolCallId: validated.toolCallId,
           });
         }
         let resolved: UnknownResolutionIntent;
-        if (existing !== undefined) {
+        if (existingIntent !== undefined) {
           // Idempotent replay of the recorded intent (author/reason may differ; the stored
           // audit fields win, exactly like requestAbort).
-          resolved = yield* unknownResolutionIntentFromRow(operation, existing);
+          resolved = existingIntent;
         } else {
           const now = yield* currentInstant;
           yield* sql`
@@ -2213,7 +2228,7 @@ const makeServices = Effect.fn("SqliteSubmissionLedger.makeServices")(function*
           });
         }
         if (parent.state !== "suspended" || parent.suspended_reason_json === null) {
-          return "not-waiting" as ChildSettledOutcome;
+          return NOT_WAITING;
         }
         const reason = yield* Schema.decodeEffect(Schema.fromJsonString(SuspensionReason))(
           parent.suspended_reason_json,
@@ -2228,12 +2243,12 @@ const makeServices = Effect.fn("SqliteSubmissionLedger.makeServices")(function*
           ),
         );
         if (reason._tag !== "WaitingForChild") {
-          return "not-waiting" as ChildSettledOutcome;
+          return NOT_WAITING;
         }
         if (
           !reason.children.some((entry) => entry.childSubmissionId === validated.childSubmissionId)
         ) {
-          return "not-waiting" as ChildSettledOutcome;
+          return NOT_WAITING;
         }
         // Every listed child must be either finalized or canonically announced from the exact
         // terminalizing reservation. Replays re-run this coverage check idempotently.
@@ -2245,7 +2260,7 @@ const makeServices = Effect.fn("SqliteSubmissionLedger.makeServices")(function*
             (listed.value.state === "settled" ||
               (listed.value.state === "terminalizing" && Option.isSome(reservation)));
           if (!covered) {
-            return "still-waiting" as ChildSettledOutcome;
+            return STILL_WAITING;
           }
         }
         yield* sql`
@@ -2256,7 +2271,7 @@ const makeServices = Effect.fn("SqliteSubmissionLedger.makeServices")(function*
             suspended_at = NULL
           WHERE submission_id = ${validated.parentSubmissionId}
         `.pipe(Effect.mapError(sqlFailure(operation)));
-        return "woken" as ChildSettledOutcome;
+        return WOKEN;
       }),
     );
     yield* hitFailpoint("ledger:child-settled:after", operation);
@@ -2279,13 +2294,17 @@ const makeServices = Effect.fn("SqliteSubmissionLedger.makeServices")(function*
       Effect.gen(function* () {
         const existing = yield* readChildReservation(operation, validated.reservationId);
         if (Option.isSome(existing)) {
+          const existingSnapshot = yield* childReservationSnapshotFromRow(
+            operation,
+            existing.value,
+          );
           // Identical replays short-circuit before the fence, mirroring reserveSettlement: a
           // replay creates nothing, so a recovering caller resumes rather than duplicates.
           const identical =
             existing.value.parent_submission_id === validated.parentSubmissionId &&
             existing.value.parent_tool_call_id === validated.parentToolCallId &&
             existing.value.allocation_digest === validated.allocationDigest &&
-            existing.value.allocation_json === allocationJson;
+            equivalentPersistedJson(existingSnapshot.allocation, validated.allocation);
           if (!identical) {
             return yield* ChildReservationConflict.make({
               reservationId: validated.reservationId,
@@ -2295,7 +2314,7 @@ const makeServices = Effect.fn("SqliteSubmissionLedger.makeServices")(function*
             });
           }
           return ReservedChildBudget.make({
-            reservation: yield* childReservationSnapshotFromRow(operation, existing.value),
+            reservation: existingSnapshot,
             replayed: true,
           });
         }
@@ -2445,10 +2464,17 @@ const makeServices = Effect.fn("SqliteSubmissionLedger.makeServices")(function*
           });
         }
         if (existing.value.status !== "reserved") {
+          const existingSnapshot = yield* childReservationSnapshotFromRow(
+            operation,
+            existing.value,
+          );
           // The accounting decision was already frozen exactly once; an identical replay is a
           // no-op and a divergent decision conflicts (spec §12 join step 6).
-          if (existing.value.accounting_json === accountingJson) {
-            return yield* childReservationSnapshotFromRow(operation, existing.value);
+          if (
+            existingSnapshot.accounting !== undefined &&
+            equivalentPersistedJson(existingSnapshot.accounting, validated.accounting)
+          ) {
+            return existingSnapshot;
           }
           return yield* ChildReservationConflict.make({
             reservationId: validated.reservationId,
@@ -2584,10 +2610,11 @@ const makeServices = Effect.fn("SqliteSubmissionLedger.makeServices")(function*
     return [snapshots, next] as const;
   });
 
-  const scanNonterminal: Stream.Stream<SubmissionSnapshot, LedgerError> = Stream.paginate(
-    undefined as ScanCursor | undefined,
-    scanPage,
-  );
+  const scanNonterminal: Stream.Stream<SubmissionSnapshot, LedgerError> = Stream.paginate<
+    ScanCursor | undefined,
+    SubmissionSnapshot,
+    LedgerError
+  >(undefined, scanPage);
 
   const loadRecoverySnapshot: SubmissionLedger["Service"]["loadRecoverySnapshot"] = Effect.fn(
     "SqliteSubmissionLedger.loadRecoverySnapshot",
@@ -2841,13 +2868,17 @@ export const submissionLedgerLayer: Layer.Layer<
 export const ledgerLayer = (
   options: SqliteStorageOptions,
 ): Layer.Layer<SubmissionLedger, SqliteStorageInitializationError> =>
-  submissionLedgerLayer.pipe(
-    Layer.provide(
-      Layer.mergeAll(
-        storageConfigLayer(options),
-        storageFailpointLayer(options),
-        SqliteClient.layer({ filename: options.filename }),
-        NodeCrypto.layer,
+  Layer.unwrap(
+    Effect.map(SqliteStorageConfig, (config) =>
+      submissionLedgerLayer.pipe(
+        Layer.provide(
+          Layer.mergeAll(
+            Layer.succeed(SqliteStorageConfig)(config),
+            storageFailpointLayer(options),
+            SqliteClient.layer({ filename: options.filename }),
+            NodeCrypto.layer,
+          ),
+        ),
       ),
     ),
-  );
+  ).pipe(Layer.provide(storageConfigLayer(options)));

package/src/sqlite-storage-failpoint.ts

@@ -1,6 +1,6 @@
 import { Context, Effect, Layer, Ref } from "effect";
 
-import { SqliteStorageFailpointError, type SqliteStorageFailpointLocation } from "./errors.ts";
+import type { SqliteStorageFailpointError, SqliteStorageFailpointLocation } from "./errors.ts";
 
 export type SqliteStorageFailpointHandler = (
   location: SqliteStorageFailpointLocation,