@effect-agent/storage-cloudflare 0.1.0-beta.8 → 0.1.0-beta.80

package/src/internal/message-delivery-schema.ts

@@ -0,0 +1,24 @@
+import { Effect } from "effect";
+import * as SqlClient from "effect/unstable/sql/SqlClient";
+
+/** Additive storage owned by this adapter; creation participates in its version transaction. */
+export const createMessageDeliveryTables = Effect.gen(function* () {
+  const sql = yield* SqlClient.SqlClient;
+
+  yield* sql`
+    CREATE TABLE effect_agent_message_deliveries (
+      owner_thread_id TEXT NOT NULL,
+      message_id TEXT NOT NULL,
+      version INTEGER NOT NULL,
+      state TEXT NOT NULL,
+      deadline_at_millis INTEGER,
+      record_json TEXT NOT NULL,
+      PRIMARY KEY (owner_thread_id, message_id)
+    )
+  `.withoutTransform;
+  yield* sql`
+    CREATE INDEX effect_agent_message_deliveries_due
+    ON effect_agent_message_deliveries (deadline_at_millis, owner_thread_id, message_id)
+    WHERE deadline_at_millis IS NOT NULL
+  `.withoutTransform;
+});

package/src/{migrations.ts → internal/migrations.ts}

@@ -2,35 +2,39 @@ import { SqliteMigrator } from "@effect/sql-sqlite-do";
 import { Effect } from "effect";
 import * as SqlClient from "effect/unstable/sql/SqlClient";
 
-/**
- * The exact-or-fresh storage version recorded in `effect_agent_meta`. Cloudflare is a fresh
- * platform, so there is exactly ONE migration carrying the complete current schema — no
- * v1→v4 history to replay (deployment spec §9: no rolling data-version promise during
- * private development).
- */
-export const CurrentDoStorageVersion = 1;
+import { createMessageDeliveryTables } from "./message-delivery-schema.ts";
+import { createRecoveryCheckpointTable } from "./recovery-checkpoint-schema.ts";
+
+/** The current storage version recorded in `effect_agent_meta`. */
+export const CurrentDoStorageVersion = 6;
+
+/** Index only outstanding obligations, ordered by the recovery scan's stable cursor. */
+export const createNonterminalIndex = Effect.gen(function* () {
+  const sql = yield* SqlClient.SqlClient;
+
+  yield* sql`CREATE INDEX effect_agent_submissions_nonterminal ON effect_agent_submissions (thread_id, queue_sequence) WHERE state <> 'settled'`
+    .withoutTransform;
+});
 
 /**
- * The Conversation Durable Object schema. Table names and columns mirror the Node/SQLite v4
- * schema byte-for-byte (`packages/storage-sqlite/src/migrations.ts`, migrations 1–4 collapsed
- * into their final shape) so the shared conformance suites and crash-matrix rows address
- * identical durable state. Two DC-specific additions:
+ * The Thread Durable Object schema shares its thread and ledger tables with Node/SQLite.
+ * Schedules and subscriptions use separate Durable Objects. Two DC-specific additions:
  *
  * 1. `effect_agent_meta` replaces `PRAGMA user_version` as the exact-or-fresh version gate —
  *    a meta table is portable regardless of which PRAGMAs Durable Object SQL storage allows.
  * 2. `effect_agent_child_settlements` is the durable cross-store notification marker the
  *    SubmissionLedger port contract mandates for cross-store adapters (`suspend`'s covering
- *    check and `recordChildSettled`'s wake both consult it): parent and child Conversations
+ *    check and `recordChildSettled`'s wake both consult it): parent and child Threads
  *    live in different Durable Objects, so a child settlement reported before the parent's
  *    suspend commits must be observable from the PARENT's own storage.
  */
 export const doMigrations = SqliteMigrator.fromRecord({
-  "1_current_cloudflare_conversation_object": Effect.gen(function* () {
+  "1_current_cloudflare_thread_object": Effect.gen(function* () {
     const sql = yield* SqlClient.SqlClient;
 
     yield* sql`
-      CREATE TABLE effect_agent_conversations (
-        conversation_id TEXT PRIMARY KEY NOT NULL,
+      CREATE TABLE effect_agent_threads (
+        thread_id TEXT PRIMARY KEY NOT NULL,
         created_at TEXT NOT NULL,
         tail_sequence INTEGER NOT NULL,
         tail_digest TEXT NOT NULL,
@@ -40,59 +44,59 @@ export const doMigrations = SqliteMigrator.fromRecord({
 
     yield* sql`
       CREATE TABLE effect_agent_canonical_batches (
-        conversation_id TEXT NOT NULL,
+        thread_id TEXT NOT NULL,
         batch_id TEXT NOT NULL,
         first_sequence INTEGER NOT NULL,
         last_sequence INTEGER NOT NULL,
         batch_digest TEXT NOT NULL,
         tail_digest TEXT NOT NULL,
         batch_json TEXT NOT NULL,
-        PRIMARY KEY (conversation_id, batch_id),
-        FOREIGN KEY (conversation_id)
-          REFERENCES effect_agent_conversations(conversation_id)
+        PRIMARY KEY (thread_id, batch_id),
+        FOREIGN KEY (thread_id)
+          REFERENCES effect_agent_threads(thread_id)
           ON DELETE RESTRICT
       )
     `.withoutTransform;
 
     yield* sql`
       CREATE TABLE effect_agent_canonical_records (
-        conversation_id TEXT NOT NULL,
+        thread_id TEXT NOT NULL,
         sequence INTEGER NOT NULL,
         record_id TEXT NOT NULL,
         batch_id TEXT NOT NULL,
         record_json TEXT NOT NULL,
-        PRIMARY KEY (conversation_id, sequence),
-        UNIQUE (conversation_id, record_id),
-        FOREIGN KEY (conversation_id, batch_id)
-          REFERENCES effect_agent_canonical_batches(conversation_id, batch_id)
+        PRIMARY KEY (thread_id, sequence),
+        UNIQUE (thread_id, record_id),
+        FOREIGN KEY (thread_id, batch_id)
+          REFERENCES effect_agent_canonical_batches(thread_id, batch_id)
           ON DELETE RESTRICT
       )
     `.withoutTransform;
 
     yield* sql`
       CREATE INDEX effect_agent_canonical_records_batch
-        ON effect_agent_canonical_records (conversation_id, batch_id, sequence)
+        ON effect_agent_canonical_records (thread_id, batch_id, sequence)
     `.withoutTransform;
 
     yield* sql`
       CREATE TABLE effect_agent_checkpoints (
-        conversation_id TEXT NOT NULL,
+        thread_id TEXT NOT NULL,
         through_sequence INTEGER NOT NULL,
         tail_digest TEXT NOT NULL,
         checkpoint_json TEXT NOT NULL,
-        PRIMARY KEY (conversation_id, through_sequence),
-        FOREIGN KEY (conversation_id)
-          REFERENCES effect_agent_conversations(conversation_id)
+        PRIMARY KEY (thread_id, through_sequence),
+        FOREIGN KEY (thread_id)
+          REFERENCES effect_agent_threads(thread_id)
           ON DELETE RESTRICT
       )
     `.withoutTransform;
 
-    // Admission rows exist before Conversation materialization (durability §4), so
-    // conversation_id intentionally carries no foreign key into effect_agent_conversations.
+    // Admission rows exist before Thread materialization (durability §4), so
+    // thread_id intentionally carries no foreign key into effect_agent_threads.
     yield* sql`
       CREATE TABLE effect_agent_submissions (
         submission_id TEXT PRIMARY KEY NOT NULL,
-        conversation_id TEXT NOT NULL,
+        thread_id TEXT NOT NULL,
         queue_sequence INTEGER NOT NULL,
         principal TEXT NOT NULL,
         idempotency_key TEXT NOT NULL,
@@ -115,8 +119,12 @@ export const doMigrations = SqliteMigrator.fromRecord({
         unknown_tool_call_ids_json TEXT,
         parent_submission_id TEXT,
         parent_tool_call_id TEXT,
-        UNIQUE (conversation_id, principal, idempotency_key),
-        UNIQUE (conversation_id, queue_sequence)
+        admission_group TEXT,
+        admission_fence_json TEXT,
+        worker_admission_json TEXT,
+        message_admission_json TEXT,
+        UNIQUE (thread_id, principal, idempotency_key),
+        UNIQUE (thread_id, queue_sequence)
       )
     `.withoutTransform;
 
@@ -130,6 +138,11 @@ export const doMigrations = SqliteMigrator.fromRecord({
         ON effect_agent_submissions (parent_submission_id)
     `.withoutTransform;
 
+    yield* sql`
+      CREATE INDEX effect_agent_submissions_group
+        ON effect_agent_submissions (thread_id, admission_group, state)
+    `.withoutTransform;
+
     yield* sql`
       CREATE TABLE effect_agent_submission_ownership (
         submission_id TEXT PRIMARY KEY NOT NULL,
@@ -148,7 +161,7 @@ export const doMigrations = SqliteMigrator.fromRecord({
       CREATE TABLE effect_agent_attempts (
         attempt_id TEXT PRIMARY KEY NOT NULL,
         submission_id TEXT NOT NULL,
-        conversation_id TEXT NOT NULL,
+        thread_id TEXT NOT NULL,
         owner_producer_id TEXT NOT NULL,
         producer_epoch INTEGER NOT NULL,
         claimed_at TEXT NOT NULL,
@@ -252,6 +265,9 @@ export const doMigrations = SqliteMigrator.fromRecord({
       )
     `.withoutTransform;
 
+    yield* createNonterminalIndex;
+    yield* createMessageDeliveryTables;
+    yield* createRecoveryCheckpointTable;
     yield* sql`
       CREATE TABLE effect_agent_meta (
         key TEXT PRIMARY KEY NOT NULL,

package/src/internal/recovery-checkpoint-schema.ts

@@ -0,0 +1,17 @@
+import { Effect } from "effect";
+import * as SqlClient from "effect/unstable/sql/SqlClient";
+
+/** One disposable recovery snapshot per Thread, independent of generic projections. */
+export const createRecoveryCheckpointTable = Effect.gen(function* () {
+  const sql = yield* SqlClient.SqlClient;
+
+  yield* sql`
+    CREATE TABLE effect_agent_recovery_checkpoints (
+      thread_id TEXT PRIMARY KEY NOT NULL,
+      through_sequence INTEGER NOT NULL,
+      tail_digest TEXT NOT NULL,
+      checkpoint_json TEXT NOT NULL,
+      FOREIGN KEY (thread_id) REFERENCES effect_agent_threads(thread_id) ON DELETE RESTRICT
+    )
+  `.withoutTransform;
+});