@effect-agent/storage-sqlite 0.1.0-beta.38 → 0.1.0-beta.39

package/src/sqlite-ledger.ts

@@ -73,7 +73,7 @@ import {
   submissionAbortRecordId,
   type ChildSettledOutcome,
   type SuspensionOutcome,
-} from "@effect-agent/session";
+} from "@effect-agent/thread";
 import { NodeCrypto } from "@effect/platform-node";
 import { SqliteClient } from "@effect/sql-sqlite-node";
 import { Clock, Context, Crypto, DateTime, Effect, Layer, Option, Schema, Stream } from "effect";
@@ -87,15 +87,15 @@ import {
   SqliteWriteContention,
   type SqliteStorageFailpointLocation,
 } from "./errors.ts";
+import { decodeRows, initializeSqliteJournal } from "./sqlite-journal.ts";
+import { SqliteStorageConfig } from "./sqlite-storage-config.ts";
+import { SqliteStorageFailpoint } from "./sqlite-storage-failpoint.ts";
 import {
   storageConfigLayer,
   storageFailpointLayer,
   type SqliteStorageInitializationError,
   type SqliteStorageOptions,
-} from "./sqlite-conversation-store.ts";
-import { decodeRows, initializeSqliteJournal } from "./sqlite-journal.ts";
-import { SqliteStorageConfig } from "./sqlite-storage-config.ts";
-import { SqliteStorageFailpoint } from "./sqlite-storage-failpoint.ts";
+} from "./sqlite-thread-store.ts";
 
 type SubmissionId = SubmissionSnapshot["submissionId"];
 
@@ -113,7 +113,7 @@ const WOKEN: ChildSettledOutcome = "woken";
 
 class SubmissionRow extends Schema.Class<SubmissionRow>("SubmissionRow")({
   submission_id: BoundedIdentifier,
-  conversation_id: BoundedIdentifier,
+  thread_id: BoundedIdentifier,
   queue_sequence: QueueSequence,
   principal: BoundedIdentifier,
   idempotency_key: BoundedIdentifier,
@@ -208,7 +208,7 @@ class CanonicalRecordIdRow extends Schema.Class<CanonicalRecordIdRow>("Canonical
 
 const SUBMISSION_COLUMNS = `
   submission_id,
-  conversation_id,
+  thread_id,
   queue_sequence,
   principal,
   idempotency_key,
@@ -247,7 +247,7 @@ const CHILD_RESERVATION_COLUMNS = `
   released_at
 `;
 
-/** The branded ToolCallId schema, reached through the session port so no core import is needed. */
+/** The branded ToolCallId schema, reached through the thread port so no core import is needed. */
 const ToolCallIdSchema = ApprovalDecisionCommand.fields.toolCallId;
 const ToolCallIdList = Schema.Array(ToolCallIdSchema);
 
@@ -448,20 +448,20 @@ const makeServices = Effect.fn("SqliteSubmissionLedger.makeServices")(function*
     return decoded.length === 0 ? Option.none() : Option.some(decoded[0]);
   });
 
-  const conversationEpoch = Effect.fn("SqliteSubmissionLedger.conversationEpoch")(function* (
+  const threadEpoch = Effect.fn("SqliteSubmissionLedger.threadEpoch")(function* (
     operation: string,
-    conversationId: string,
+    threadId: string,
   ): Effect.fn.Return<ProducerEpoch, LedgerError> {
-    const conversations = yield* journal
-      .getConversation(conversationId)
+    const threads = yield* journal
+      .getThread(threadId)
       .pipe(Effect.mapError(internalFailure(operation)));
-    return conversations.length === 0 ? EPOCH_ZERO : conversations[0].producer_epoch;
+    return threads.length === 0 ? EPOCH_ZERO : threads[0].producer_epoch;
   });
 
   /**
    * Verify inside the surrounding write transaction that the presented token still owns the
    * Submission's lane; a superseded or missing token fails with OwnershipLost carrying the
-   * Conversation's current producer epoch (DUR-006).
+   * Thread's current producer epoch (DUR-006).
    */
   const requireOwnership = Effect.fn("SqliteSubmissionLedger.requireOwnership")(function* (
     operation: string,
@@ -470,7 +470,7 @@ const makeServices = Effect.fn("SqliteSubmissionLedger.makeServices")(function*
   ): Effect.fn.Return<OwnershipRow, OwnershipLost | LedgerError> {
     const ownership = yield* readOwnership(operation, submission.submission_id);
     if (Option.isNone(ownership) || ownership.value.ownership_token !== ownershipToken) {
-      const actualEpoch = yield* conversationEpoch(operation, submission.conversation_id);
+      const actualEpoch = yield* threadEpoch(operation, submission.thread_id);
       const submissionId = yield* Schema.decodeUnknownEffect(
         SubmissionSnapshot.fields.submissionId,
       )(submission.submission_id).pipe(Effect.mapError(internalFailure(operation)));
@@ -514,7 +514,7 @@ const makeServices = Effect.fn("SqliteSubmissionLedger.makeServices")(function*
       }
       return yield* decodeSubmissionSnapshotUnknown({
         submissionId: row.submission_id,
-        conversationId: row.conversation_id,
+        threadId: row.thread_id,
         queueSequence: row.queue_sequence,
         principal: row.principal,
         idempotencyKey: row.idempotency_key,
@@ -847,20 +847,20 @@ const makeServices = Effect.fn("SqliteSubmissionLedger.makeServices")(function*
   const canonicalAbortRecordId = Effect.fn("SqliteSubmissionLedger.canonicalAbortRecordId")(
     function* (
       operation: string,
-      conversationId: string,
+      threadId: string,
       submissionId: SubmissionId,
     ): Effect.fn.Return<string | undefined, LedgerError> {
       const recordId = submissionAbortRecordId(submissionId);
       const rows = yield* sql<Record<string, unknown>>`
         SELECT record_id
         FROM effect_agent_canonical_records
-        WHERE conversation_id = ${conversationId}
+        WHERE thread_id = ${threadId}
           AND record_id = ${recordId}
       `.pipe(Effect.mapError(sqlFailure(operation)));
       const decoded = yield* decodeRows(
         Schema.Array(CanonicalRecordIdRow),
         "effect_agent_canonical_records",
-        `${conversationId}/${recordId}`,
+        `${threadId}/${recordId}`,
         rows,
       ).pipe(Effect.mapError(internalFailure(operation)));
       return decoded.length === 0 ? undefined : recordId;
@@ -875,7 +875,7 @@ const makeServices = Effect.fn("SqliteSubmissionLedger.makeServices")(function*
   ): Effect.fn.Return<AbortIntent, LedgerError> {
     const canonicalRecordId = yield* canonicalAbortRecordId(
       operation,
-      submission.conversation_id,
+      submission.thread_id,
       submissionId,
     );
     return yield* decodeAbortIntent({
@@ -916,11 +916,11 @@ const makeServices = Effect.fn("SqliteSubmissionLedger.makeServices")(function*
       const result = yield* inWriteTransaction(
         operation,
         Effect.gen(function* () {
-          const keyRowKey = `${validated.conversationId}/${validated.principal}/${validated.idempotencyKey}`;
+          const keyRowKey = `${validated.threadId}/${validated.principal}/${validated.idempotencyKey}`;
           const existingRows = yield* sql<Record<string, unknown>>`
             SELECT ${sql.literal(SUBMISSION_COLUMNS)}
             FROM effect_agent_submissions
-            WHERE conversation_id = ${validated.conversationId}
+            WHERE thread_id = ${validated.threadId}
               AND principal = ${validated.principal}
               AND idempotency_key = ${validated.idempotencyKey}
           `.pipe(Effect.mapError(sqlFailure(operation)));
@@ -944,7 +944,7 @@ const makeServices = Effect.fn("SqliteSubmissionLedger.makeServices")(function*
                   existing[0].parent_tool_call_id === validated.parentLinkage.parentToolCallId;
             if (existing[0].input_digest !== validated.inputDigest || !sameLinkage) {
               return yield* AdmissionConflict.make({
-                conversationId: validated.conversationId,
+                threadId: validated.threadId,
                 principal: validated.principal,
                 idempotencyKey: validated.idempotencyKey,
                 existingInputDigest: existing[0].input_digest,
@@ -963,12 +963,12 @@ const makeServices = Effect.fn("SqliteSubmissionLedger.makeServices")(function*
           const maxRows = yield* sql<Record<string, unknown>>`
             SELECT COALESCE(MAX(queue_sequence), 0) AS max_queue_sequence
             FROM effect_agent_submissions
-            WHERE conversation_id = ${validated.conversationId}
+            WHERE thread_id = ${validated.threadId}
           `.pipe(Effect.mapError(sqlFailure(operation)));
           const decodedMax = yield* decodeRows(
             Schema.Array(MaxQueueSequenceRow),
             "effect_agent_submissions",
-            validated.conversationId,
+            validated.threadId,
             maxRows,
           ).pipe(Effect.mapError(internalFailure(operation)));
           const queueSequence = yield* decodeQueueSequence(
@@ -979,7 +979,7 @@ const makeServices = Effect.fn("SqliteSubmissionLedger.makeServices")(function*
           yield* sql`
             INSERT INTO effect_agent_submissions (
               submission_id,
-              conversation_id,
+              thread_id,
               queue_sequence,
               principal,
               idempotency_key,
@@ -995,7 +995,7 @@ const makeServices = Effect.fn("SqliteSubmissionLedger.makeServices")(function*
               parent_tool_call_id
             ) VALUES (
               ${mintedSubmissionId},
-              ${validated.conversationId},
+              ${validated.threadId},
               ${queueSequence},
               ${validated.principal},
               ${validated.idempotencyKey},
@@ -1064,20 +1064,20 @@ const makeServices = Effect.fn("SqliteSubmissionLedger.makeServices")(function*
       const rows = yield* sql<Record<string, unknown>>`
       SELECT ${sql.literal(SUBMISSION_COLUMNS)}
       FROM effect_agent_submissions
-      WHERE conversation_id = ${validated.conversationId}
+      WHERE thread_id = ${validated.threadId}
         AND principal = ${validated.principal}
         AND idempotency_key = ${validated.idempotencyKey}
     `.pipe(Effect.mapError(sqlFailure(operation)));
       const decoded = yield* decodeSubmissionRows(
         operation,
-        `${validated.conversationId}/${validated.principal}/${validated.idempotencyKey}`,
+        `${validated.threadId}/${validated.principal}/${validated.idempotencyKey}`,
         rows,
       );
       if (decoded.length > 1) {
         return yield* corruptionFailure(
           operation,
           "effect_agent_submissions",
-          `${validated.conversationId}/${validated.principal}/${validated.idempotencyKey}`,
+          `${validated.threadId}/${validated.principal}/${validated.idempotencyKey}`,
           "An admission idempotency key returned more than one row.",
         );
       }
@@ -1099,20 +1099,20 @@ const makeServices = Effect.fn("SqliteSubmissionLedger.makeServices")(function*
     const rows = yield* sql<Record<string, unknown>>`
       SELECT ${sql.literal(SUBMISSION_COLUMNS)}
       FROM effect_agent_submissions
-      WHERE conversation_id = ${validated.conversationId}
+      WHERE thread_id = ${validated.threadId}
         AND principal = ${validated.principal}
         AND idempotency_key = ${validated.idempotencyKey}
     `.pipe(Effect.mapError(sqlFailure(operation)));
     const decoded = yield* decodeSubmissionRows(
       operation,
-      `${validated.conversationId}/${validated.principal}/${validated.idempotencyKey}`,
+      `${validated.threadId}/${validated.principal}/${validated.idempotencyKey}`,
       rows,
     );
     if (decoded.length > 1) {
       return yield* corruptionFailure(
         operation,
         "effect_agent_submissions",
-        `${validated.conversationId}/${validated.principal}/${validated.idempotencyKey}`,
+        `${validated.threadId}/${validated.principal}/${validated.idempotencyKey}`,
         "An admission idempotency key returned more than one row.",
       );
     }
@@ -1137,12 +1137,12 @@ const makeServices = Effect.fn("SqliteSubmissionLedger.makeServices")(function*
           const headRows = yield* sql<Record<string, unknown>>`
             SELECT ${sql.literal(SUBMISSION_COLUMNS)}
             FROM effect_agent_submissions
-            WHERE conversation_id = ${validated.conversationId}
+            WHERE thread_id = ${validated.threadId}
               AND state <> 'settled'
             ORDER BY queue_sequence ASC
             LIMIT 1
           `.pipe(Effect.mapError(sqlFailure(operation)));
-          const heads = yield* decodeSubmissionRows(operation, validated.conversationId, headRows);
+          const heads = yield* decodeSubmissionRows(operation, validated.threadId, headRows);
           if (heads.length === 0) return Option.none<Claim>();
           const head = heads[0];
 
@@ -1171,25 +1171,25 @@ const makeServices = Effect.fn("SqliteSubmissionLedger.makeServices")(function*
             if (expiresAt > now.millis) return Option.none<Claim>();
           }
 
-          // Bump the Conversation's producer epoch atomically with the claim so every stale
-          // Attempt is fenced out of canonical appends (DUR-006). A Conversation that was
+          // Bump the Thread's producer epoch atomically with the claim so every stale
+          // Attempt is fenced out of canonical appends (DUR-006). A Thread that was
           // never materialized (crash between admission and materialization) is created here
           // so recovery can claim first and re-materialize idempotently at this epoch.
-          const conversations = yield* journal
-            .getConversation(head.conversation_id)
+          const threads = yield* journal
+            .getThread(head.thread_id)
             .pipe(Effect.mapError(internalFailure(operation)));
           let producerEpoch: number;
-          if (conversations.length === 0) {
+          if (threads.length === 0) {
             producerEpoch = 1;
             yield* sql`
-              INSERT INTO effect_agent_conversations (
-                conversation_id,
+              INSERT INTO effect_agent_threads (
+                thread_id,
                 created_at,
                 tail_sequence,
                 tail_digest,
                 producer_epoch
               ) VALUES (
-                ${head.conversation_id},
+                ${head.thread_id},
                 ${now.iso},
                 0,
                 ${EMPTY_TAIL_DIGEST},
@@ -1197,11 +1197,11 @@ const makeServices = Effect.fn("SqliteSubmissionLedger.makeServices")(function*
               )
             `.pipe(Effect.mapError(sqlFailure(operation)));
           } else {
-            producerEpoch = conversations[0].producer_epoch + 1;
+            producerEpoch = threads[0].producer_epoch + 1;
             yield* sql`
-              UPDATE effect_agent_conversations
+              UPDATE effect_agent_threads
               SET producer_epoch = ${producerEpoch}
-              WHERE conversation_id = ${head.conversation_id}
+              WHERE thread_id = ${head.thread_id}
             `.pipe(Effect.mapError(sqlFailure(operation)));
           }
 
@@ -1234,14 +1234,14 @@ const makeServices = Effect.fn("SqliteSubmissionLedger.makeServices")(function*
             INSERT INTO effect_agent_attempts (
               attempt_id,
               submission_id,
-              conversation_id,
+              thread_id,
               owner_producer_id,
               producer_epoch,
               claimed_at
             ) VALUES (
               ${attemptId},
               ${head.submission_id},
-              ${head.conversation_id},
+              ${head.thread_id},
               ${validated.producerId},
               ${producerEpoch},
               ${now.iso}
@@ -1673,7 +1673,7 @@ const makeServices = Effect.fn("SqliteSubmissionLedger.makeServices")(function*
         `.pipe(Effect.mapError(sqlFailure(operation)));
         const canonicalRecordId = yield* canonicalAbortRecordId(
           operation,
-          submission.conversation_id,
+          submission.thread_id,
           validated.submissionId,
         );
         return yield* decodeAbortIntent({
@@ -1701,10 +1701,10 @@ const makeServices = Effect.fn("SqliteSubmissionLedger.makeServices")(function*
       operation,
       Effect.gen(function* () {
         const host = yield* requireSubmission(operation, validated.hostSubmissionId);
-        if (host.conversation_id !== validated.conversationId) {
+        if (host.thread_id !== validated.threadId) {
           return yield* LedgerError.make({
             operation,
-            message: `Host submission ${validated.hostSubmissionId} does not belong to conversation ${validated.conversationId}.`,
+            message: `Host submission ${validated.hostSubmissionId} does not belong to thread ${validated.threadId}.`,
           });
         }
         // The host Attempt already owns the lane; no epoch bump happens here (plan §2.5).
@@ -1712,11 +1712,11 @@ const makeServices = Effect.fn("SqliteSubmissionLedger.makeServices")(function*
         const laterRows = yield* sql<Record<string, unknown>>`
           SELECT ${sql.literal(SUBMISSION_COLUMNS)}
           FROM effect_agent_submissions
-          WHERE conversation_id = ${validated.conversationId}
+          WHERE thread_id = ${validated.threadId}
             AND queue_sequence > ${host.queue_sequence}
           ORDER BY queue_sequence ASC
         `.pipe(Effect.mapError(sqlFailure(operation)));
-        const later = yield* decodeSubmissionRows(operation, validated.conversationId, laterRows);
+        const later = yield* decodeSubmissionRows(operation, validated.threadId, laterRows);
         const claimed: Array<JoiningClaim> = [];
         for (const row of later) {
           if (claimed.length >= validated.maxCount) break;
@@ -2561,7 +2561,7 @@ const makeServices = Effect.fn("SqliteSubmissionLedger.makeServices")(function*
   });
 
   interface ScanCursor {
-    readonly conversationId: string;
+    readonly threadId: string;
     readonly queueSequence: number;
   }
 
@@ -2578,7 +2578,7 @@ const makeServices = Effect.fn("SqliteSubmissionLedger.makeServices")(function*
           SELECT ${sql.literal(SUBMISSION_COLUMNS)}
           FROM effect_agent_submissions
           WHERE state <> 'settled'
-          ORDER BY conversation_id ASC, queue_sequence ASC
+          ORDER BY thread_id ASC, queue_sequence ASC
           LIMIT ${SCAN_PAGE_SIZE}
         `
         : sql<Record<string, unknown>>`
@@ -2586,13 +2586,13 @@ const makeServices = Effect.fn("SqliteSubmissionLedger.makeServices")(function*
           FROM effect_agent_submissions
           WHERE state <> 'settled'
             AND (
-              conversation_id > ${cursor.conversationId}
+              thread_id > ${cursor.threadId}
               OR (
-                conversation_id = ${cursor.conversationId}
+                thread_id = ${cursor.threadId}
                 AND queue_sequence > ${cursor.queueSequence}
               )
             )
-          ORDER BY conversation_id ASC, queue_sequence ASC
+          ORDER BY thread_id ASC, queue_sequence ASC
           LIMIT ${SCAN_PAGE_SIZE}
         `
     ).pipe(Effect.mapError(sqlFailure(operation)));
@@ -2605,7 +2605,7 @@ const makeServices = Effect.fn("SqliteSubmissionLedger.makeServices")(function*
       last === undefined || decoded.length < SCAN_PAGE_SIZE
         ? Option.none()
         : Option.some({
-            conversationId: last.conversation_id,
+            threadId: last.thread_id,
             queueSequence: last.queue_sequence,
           });
     return [snapshots, next] as const;
@@ -2864,7 +2864,7 @@ export const submissionLedgerLayer: Layer.Layer<
 
 /**
  * A composition-root convenience Layer for the durable Submission Ledger. Point it at the
- * same database file as the ConversationStore so claims fence the same producer epochs.
+ * same database file as the ThreadStore so claims fence the same producer epochs.
  */
 export const ledgerLayer = (
   options: SqliteStorageOptions,

package/src/sqlite-schedule-store.ts

@@ -18,14 +18,14 @@ import {
   ScheduleStorageError,
   ScheduleStore,
   scheduleDeadline,
-} from "@effect-agent/session";
+} from "@effect-agent/thread";
 import { Effect, Layer, Result, Schema } from "effect";
 import * as SqlClientService from "effect/unstable/sql/SqlClient";
 
-import type { SqliteStorageInitializationError } from "./sqlite-conversation-store.ts";
 import { initializeSqliteJournal } from "./sqlite-journal.ts";
 import type { SqliteStorageConfig } from "./sqlite-storage-config.ts";
 import type { SqliteStorageFailpoint } from "./sqlite-storage-failpoint.ts";
+import type { SqliteStorageInitializationError } from "./sqlite-thread-store.ts";
 
 // Configuration and the immutable pending envelope may each carry the canonical input. Leave
 // room for JSON escaping and bounded status while rejecting an unreadable oversized row.

package/src/sqlite-storage-config.ts

@@ -19,7 +19,7 @@ export class SqliteStorageConfigValue extends Schema.Class<SqliteStorageConfigVa
    * Submission ownership lease duration in milliseconds (D5). The lease is a liveness hint
    * that makes an abandoned claim reclaimable; correctness never depends on it because every
    * canonical append is fenced by producer epoch. Convenience layers default this to
-   * `DEFAULT_OWNERSHIP_LEASE_DURATION` from `@effect-agent/session`.
+   * `DEFAULT_OWNERSHIP_LEASE_DURATION` from `@effect-agent/thread`.
    */
   ownershipLeaseDuration: OwnershipLeaseMillis,
   /**

package/src/sqlite-storage-failpoint-testing.ts

@@ -0,0 +1,38 @@
+import { Context, Effect, Layer, Ref } from "effect";
+
+import {
+  SqliteStorageFailpoint,
+  type SqliteStorageFailpointHandler,
+} from "./sqlite-storage-failpoint.ts";
+
+const noFailpoint: SqliteStorageFailpointHandler = () => Effect.void;
+
+/** Test-only control for replacing the active SQLite failpoint handler. */
+export class SqliteStorageFailpointTestControl extends Context.Service<
+  SqliteStorageFailpointTestControl,
+  {
+    readonly clear: Effect.Effect<void>;
+    readonly setHandler: (handler: SqliteStorageFailpointHandler) => Effect.Effect<void>;
+  }
+>()("@effect-agent/storage-sqlite/SqliteStorageFailpointTestControl") {
+  /** Reusable test Layer with a control service backed by the same handler Ref. */
+  static readonly layer = Layer.effectContext(
+    Effect.gen(function* () {
+      const handler = yield* Ref.make<SqliteStorageFailpointHandler>(noFailpoint);
+      return Context.make(
+        SqliteStorageFailpoint,
+        SqliteStorageFailpoint.of({
+          hit: (location) => Ref.get(handler).pipe(Effect.flatMap((current) => current(location))),
+        }),
+      ).pipe(
+        Context.add(
+          SqliteStorageFailpointTestControl,
+          SqliteStorageFailpointTestControl.of({
+            clear: Ref.set(handler, noFailpoint),
+            setHandler: (next) => Ref.set(handler, next),
+          }),
+        ),
+      );
+    }),
+  );
+}

package/src/sqlite-storage-failpoint.ts

@@ -1,4 +1,4 @@
-import { Context, Effect, Layer, Ref } from "effect";
+import { Context, Effect, Layer } from "effect";
 
 import type { SqliteStorageFailpointError, SqliteStorageFailpointLocation } from "./errors.ts";
 
@@ -8,15 +8,6 @@ export type SqliteStorageFailpointHandler = (
 
 const noFailpoint: SqliteStorageFailpointHandler = () => Effect.void;
 
-/** Test-only control for replacing the active SQLite failpoint handler. */
-export class SqliteStorageFailpointTestControl extends Context.Service<
-  SqliteStorageFailpointTestControl,
-  {
-    readonly clear: Effect.Effect<void>;
-    readonly setHandler: (handler: SqliteStorageFailpointHandler) => Effect.Effect<void>;
-  }
->()("@effect-agent/storage-sqlite/SqliteStorageFailpointTestControl") {}
-
 /** Explicit fault-injection authority used at SQLite operation boundaries. */
 export class SqliteStorageFailpoint extends Context.Service<
   SqliteStorageFailpoint,
@@ -26,25 +17,4 @@ export class SqliteStorageFailpoint extends Context.Service<
 >()("@effect-agent/storage-sqlite/SqliteStorageFailpoint") {
   /** Production default: no fault injection. */
   static readonly layer = Layer.succeed(this)({ hit: noFailpoint });
-
-  /** Reusable test Layer with a control service backed by the same handler Ref. */
-  static readonly layerTest = Layer.effectContext(
-    Effect.gen(function* () {
-      const handler = yield* Ref.make<SqliteStorageFailpointHandler>(noFailpoint);
-      return Context.make(
-        SqliteStorageFailpoint,
-        SqliteStorageFailpoint.of({
-          hit: (location) => Ref.get(handler).pipe(Effect.flatMap((current) => current(location))),
-        }),
-      ).pipe(
-        Context.add(
-          SqliteStorageFailpointTestControl,
-          SqliteStorageFailpointTestControl.of({
-            clear: Ref.set(handler, noFailpoint),
-            setHandler: (next) => Ref.set(handler, next),
-          }),
-        ),
-      );
-    }),
-  );
 }