@effect-agent/storage-cloudflare 0.1.0-beta.42 → 0.1.0-beta.45

package/src/do-thread-store.ts

@@ -140,10 +140,13 @@ const parseOffset = Effect.fn(function* (
   offset: ObservationOffset | undefined,
 ): Effect.fn.Return<CanonicalSequence, ThreadStoreError> {
   if (offset === undefined) return ZERO_CANONICAL_SEQUENCE;
+
   const text = yield* Schema.decodeUnknownEffect(OffsetText)(offset).pipe(
     Effect.mapError((error) => schemaStoreError("decode observation offset", error)),
   );
+
   const threadPrefix = `${DO_OFFSET_PREFIX}${encodeURIComponent(threadId)}:`;
+
   if (!text.startsWith(threadPrefix)) {
     return yield* ThreadStoreError.make({
       operation: "decode observation offset",
@@ -151,12 +154,14 @@ const parseOffset = Effect.fn(function* (
     });
   }
   const sequenceText = text.slice(threadPrefix.length);
+
   if (!/^(0|[1-9][0-9]*)$/.test(sequenceText)) {
     return yield* ThreadStoreError.make({
       operation: "decode observation offset",
       message: "The observation offset is malformed.",
     });
   }
+
   return yield* Schema.decodeUnknownEffect(CanonicalSequence)(Number(sequenceText)).pipe(
     Effect.mapError((error) => schemaStoreError("decode observation offset", error)),
   );
@@ -209,13 +214,17 @@ const decodeEnvelope = Effect.fn(function* (row: {
       }),
     ),
   );
+
   const threadId = yield* Schema.decodeUnknownEffect(CanonicalRecordEnvelope.fields.threadId)(
     row.thread_id,
   ).pipe(Effect.mapError((error) => schemaStoreError("decode thread identity", error)));
+
   const offset = yield* makeOffset(threadId, row.sequence);
+
   const batchId = yield* Schema.decodeUnknownEffect(CanonicalRecordEnvelope.fields.batchId)(
     row.batch_id,
   ).pipe(Effect.mapError((error) => schemaStoreError("decode batch identity", error)));
+
   return CanonicalRecordEnvelope.make({
     threadId,
     batchId,
@@ -240,9 +249,11 @@ const requireThread = Effect.fn("DoThreadStore.requireThread")(function* (
   const rows = yield* journal
     .getThread(threadId)
     .pipe(Effect.mapError((error) => storeError("read thread", error)));
+
   if (rows.length === 0) {
     return yield* ThreadNotMaterialized.make({ threadId });
   }
+
   return rows[0];
 });
 
@@ -252,15 +263,18 @@ const tailDigestAt = Effect.fn("DoThreadStore.tailDigestAt")(function* (
   sequence: CanonicalSequence,
 ) {
   if (sequence === 0) return EMPTY_TAIL_DIGEST;
+
   const digests = yield* journal
     .getTailDigestAt(threadId, sequence)
     .pipe(Effect.mapError((error) => storeError("read checkpoint digest", error)));
+
   if (digests.length !== 1) {
     return yield* CheckpointRejected.make({
       threadId,
       reason: "digest-mismatch",
     });
   }
+
   return yield* Schema.decodeUnknownEffect(Digest)(digests[0]).pipe(
     Effect.mapError((error) => schemaStoreError("decode checkpoint digest", error)),
   );
@@ -271,14 +285,17 @@ const groupByKey = <A>(
   key: (row: A) => string,
 ): ReadonlyMap<string, ReadonlyArray<A>> => {
   const grouped = new Map<string, Array<A>>();
+
   for (const row of rows) {
     const existing = grouped.get(key(row));
+
     if (existing === undefined) {
       grouped.set(key(row), [row]);
     } else {
       existing.push(row);
     }
   }
+
   return grouped;
 };
 
@@ -292,6 +309,7 @@ const decodeStartupPayloads = Effect.fn("DoThreadStore.decodeStartupPayloads")(f
   crypto: Crypto.Crypto,
 ) {
   const stored = yield* journal.scanStoredPayloads();
+
   const batches = yield* Effect.forEach(stored.batches, (batch) =>
     Schema.decodeEffect(Schema.fromJsonString(CanonicalBatch))(batch.batch_json).pipe(
       Effect.map((decoded) => ({ decoded, row: batch })),
@@ -304,6 +322,7 @@ const decodeStartupPayloads = Effect.fn("DoThreadStore.decodeStartupPayloads")(f
       ),
     ),
   );
+
   const records = yield* Effect.forEach(stored.records, (record) =>
     Schema.decodeEffect(Schema.fromJsonString(CanonicalRecord))(record.record_json).pipe(
       Effect.map((decoded) => ({ decoded, row: record })),
@@ -316,6 +335,7 @@ const decodeStartupPayloads = Effect.fn("DoThreadStore.decodeStartupPayloads")(f
       ),
     ),
   );
+
   const checkpoints = yield* Effect.forEach(stored.checkpoints, (checkpoint) =>
     Schema.decodeEffect(Schema.fromJsonString(ThreadCheckpoint))(checkpoint.checkpoint_json).pipe(
       Effect.map((decoded) => ({ decoded, row: checkpoint })),
@@ -345,6 +365,7 @@ const decodeStartupPayloads = Effect.fn("DoThreadStore.decodeStartupPayloads")(f
 
     for (const { decoded: canonicalBatch, row: batchRow } of threadBatches) {
       const key = `${batchRow.thread_id}/${batchRow.batch_id}`;
+
       if (
         canonicalBatch.batchId !== batchRow.batch_id ||
         batchRow.first_sequence !== expectedSequence ||
@@ -367,6 +388,7 @@ const decodeStartupPayloads = Effect.fn("DoThreadStore.decodeStartupPayloads")(f
           }),
         ),
       );
+
       if (batchRow.batch_digest !== digest || batchRow.tail_digest !== digest) {
         return yield* DoStorageCorruptionError.make({
           table: "effect_agent_canonical_batches",
@@ -376,6 +398,7 @@ const decodeStartupPayloads = Effect.fn("DoThreadStore.decodeStartupPayloads")(f
       }
 
       const batchRecords = recordsByBatch.get(batchRow.batch_id) ?? [];
+
       if (batchRecords.length !== canonicalBatch.records.length) {
         return yield* DoStorageCorruptionError.make({
           table: "effect_agent_canonical_records",
@@ -386,6 +409,7 @@ const decodeStartupPayloads = Effect.fn("DoThreadStore.decodeStartupPayloads")(f
       for (let index = 0; index < canonicalBatch.records.length; index++) {
         const expectedRecord = canonicalBatch.records[index];
         const storedRecord = batchRecords[index];
+
         const expectedJson = yield* Schema.encodeEffect(Schema.fromJsonString(CanonicalRecord))(
           expectedRecord,
         ).pipe(
@@ -397,6 +421,7 @@ const decodeStartupPayloads = Effect.fn("DoThreadStore.decodeStartupPayloads")(f
             }),
           ),
         );
+
         const storedJson = yield* Schema.encodeEffect(Schema.fromJsonString(CanonicalRecord))(
           storedRecord.decoded,
         ).pipe(
@@ -408,6 +433,7 @@ const decodeStartupPayloads = Effect.fn("DoThreadStore.decodeStartupPayloads")(f
             }),
           ),
         );
+
         if (
           storedRecord.row.sequence !== batchRow.first_sequence + index ||
           storedRecord.row.record_id !== expectedRecord.recordId ||
@@ -473,12 +499,14 @@ const makeServices = Effect.fn("DoThreadStore.makeServices")(function* () {
   const sql = yield* SqlClientService.SqlClient;
   const crypto = yield* Crypto.Crypto;
   const journal = yield* initializeDoJournal(sql, failpoint.hit, config.maxStoredValueBytes);
+
   if (config.verifyOnOpen) {
     yield* decodeStartupPayloads(journal, crypto);
   }
 
   const provideCrypto = <A, E>(effect: Effect.Effect<A, E, Crypto.Crypto>) =>
     Effect.provideService(effect, Crypto.Crypto, crypto);
+
   const hitFailpoint = Effect.fn(
     (location: DoStorageFailpointLocation): Effect.Effect<void, ThreadStoreError> =>
       failpoint
@@ -491,7 +519,9 @@ const makeServices = Effect.fn("DoThreadStore.makeServices")(function* () {
       const validated = yield* Schema.decodeUnknownEffect(Schema.toType(ThreadMaterialization))(
         request,
       ).pipe(Effect.mapError((error) => schemaStoreError("validate materialization", error)));
+
       const now = yield* Clock.currentTimeMillis;
+
       yield* hitFailpoint("materialize:before");
       yield* journal
         .materialize(
@@ -517,11 +547,15 @@ const makeServices = Effect.fn("DoThreadStore.makeServices")(function* () {
     const validated = yield* Schema.decodeUnknownEffect(Schema.toType(FencedAppendRequest))(
       request,
     ).pipe(Effect.mapError((error) => schemaStoreError("validate canonical append", error)));
+
     yield* requireThread(journal, validated.threadId);
+
     const tailDigest = yield* provideCrypto(
       digestCanonicalBatch(validated.expectedTailDigest, validated.batch),
     ).pipe(Effect.mapError((error) => storeError("digest canonical append", error)));
+
     const batchJson = yield* encodeCanonicalBatch(validated.batch);
+
     const rawRecords = yield* Effect.forEach(validated.batch.records, (record) =>
       encodeCanonicalRecord(record).pipe(
         Effect.map((recordJson) => ({
@@ -530,6 +564,7 @@ const makeServices = Effect.fn("DoThreadStore.makeServices")(function* () {
         })),
       ),
     );
+
     const rawRequest = yield* Schema.decodeUnknownEffect(RawAppendRequest)({
       threadId: validated.threadId,
       batchId: validated.batch.batchId,
@@ -541,7 +576,9 @@ const makeServices = Effect.fn("DoThreadStore.makeServices")(function* () {
       records: rawRecords,
       tailDigest,
     }).pipe(Effect.mapError((error) => schemaStoreError("encode canonical append", error)));
+
     yield* hitFailpoint("append:before");
+
     const result = yield* journal.append(rawRequest).pipe(
       Effect.mapError((error) => {
         if (isDoFenceRejected(error)) {
@@ -562,6 +599,7 @@ const makeServices = Effect.fn("DoThreadStore.makeServices")(function* () {
                 reason: error.reason,
               });
         }
+
         return storeError("append canonical batch", error);
       }),
       Effect.flatMap((result) =>
@@ -570,7 +608,9 @@ const makeServices = Effect.fn("DoThreadStore.makeServices")(function* () {
         ),
       ),
     );
+
     yield* hitFailpoint("append:after");
+
     return result;
   });
 
@@ -578,6 +618,7 @@ const makeServices = Effect.fn("DoThreadStore.makeServices")(function* () {
     const rows = yield* journal
       .read(request)
       .pipe(Effect.mapError((error) => storeError("read canonical records", error)));
+
     return yield* Effect.forEach(rows, decodeEnvelope);
   });
 
@@ -585,7 +626,9 @@ const makeServices = Effect.fn("DoThreadStore.makeServices")(function* () {
     const validated = yield* Schema.decodeUnknownEffect(Schema.toType(ThreadRead))(request).pipe(
       Effect.mapError((error) => schemaStoreError("validate thread read", error)),
     );
+
     yield* requireThread(journal, validated.threadId);
+
     const records = yield* loadRecords(
       RawReadRequest.make({
         threadId: validated.threadId,
@@ -593,19 +636,24 @@ const makeServices = Effect.fn("DoThreadStore.makeServices")(function* () {
         limit: validated.limit,
       }),
     );
+
     return Stream.fromIterable(records);
   });
+
   const read: ThreadStore["Service"]["read"] = (request) => Stream.unwrap(readEffect(request));
 
   const observeEffect = Effect.fn("DoThreadStore.observe")(function* (request: ThreadObservation) {
     const validated = yield* Schema.decodeUnknownEffect(Schema.toType(ThreadObservation))(
       request,
     ).pipe(Effect.mapError((error) => schemaStoreError("validate thread observation", error)));
+
     yield* requireThread(journal, validated.threadId);
     const initialSequence = yield* parseOffset(validated.threadId, validated.afterOffset);
     const cursor = yield* Ref.make(initialSequence);
+
     const poll = Effect.fn("DoThreadStore.observePoll")(function* () {
       const fromSequenceExclusive = yield* Ref.get(cursor);
+
       const records = yield* loadRecords(
         RawReadRequest.make({
           threadId: validated.threadId,
@@ -613,15 +661,20 @@ const makeServices = Effect.fn("DoThreadStore.makeServices")(function* () {
           limit: 1_024,
         }),
       );
+
       if (records.length === 0) {
         yield* Effect.sleep(config.observationPollInterval);
+
         return [];
       }
       yield* Ref.set(cursor, records[records.length - 1].sequence);
+
       return records;
     });
+
     return Stream.fromIterableEffectRepeat(poll());
   });
+
   const observe: ThreadStore["Service"]["observe"] = (request) =>
     Stream.unwrap(observeEffect(request));
 
@@ -630,20 +683,26 @@ const makeServices = Effect.fn("DoThreadStore.makeServices")(function* () {
       const validated = yield* Schema.decodeUnknownEffect(Schema.toType(ThreadExportRequest))(
         request,
       ).pipe(Effect.mapError((error) => schemaStoreError("validate thread export", error)));
+
       yield* requireThread(journal, validated.threadId);
+
       const exported = yield* journal
         .exportThread(validated.threadId)
         .pipe(Effect.mapError((error) => storeError("export thread", error)));
+
       const records = yield* Effect.forEach(exported.records, decodeEnvelope);
+
       if (records.length > 65_536) {
         return yield* ThreadStoreError.make({
           operation: "decode thread export",
           message: "The thread exceeds the current export record limit.",
         });
       }
+
       const tailDigest = yield* Schema.decodeUnknownEffect(Digest)(
         exported.thread.tail_digest,
       ).pipe(Effect.mapError((error) => schemaStoreError("decode export tail digest", error)));
+
       return ThreadExport.make({
         format: "effect-agent/thread@1",
         threadId: validated.threadId,
@@ -659,10 +718,13 @@ const makeServices = Effect.fn("DoThreadStore.makeServices")(function* () {
       const validated = yield* Schema.decodeUnknownEffect(Schema.toType(ThreadTailRequest))(
         request,
       ).pipe(Effect.mapError((error) => schemaStoreError("validate tail inspection", error)));
+
       const thread = yield* requireThread(journal, validated.threadId);
+
       const tailDigest = yield* Schema.decodeUnknownEffect(Digest)(thread.tail_digest).pipe(
         Effect.mapError((error) => schemaStoreError("decode tail digest", error)),
       );
+
       return ThreadTail.make({
         threadId: validated.threadId,
         tailSequence: thread.tail_sequence,
@@ -677,18 +739,22 @@ const makeServices = Effect.fn("DoThreadStore.makeServices")(function* () {
       const validated = yield* Schema.decodeUnknownEffect(Schema.toType(SaveCheckpointRequest))(
         request,
       ).pipe(Effect.mapError((error) => schemaStoreError("validate checkpoint", error)));
+
       const thread = yield* requireThread(journal, validated.checkpoint.threadId);
+
       if (validated.checkpoint.throughSequence > thread.tail_sequence) {
         return yield* CheckpointRejected.make({
           threadId: validated.checkpoint.threadId,
           reason: "ahead-of-tail",
         });
       }
+
       const canonicalDigest = yield* tailDigestAt(
         journal,
         validated.checkpoint.threadId,
         validated.checkpoint.throughSequence,
       );
+
       if (canonicalDigest !== validated.checkpoint.tailDigest) {
         return yield* CheckpointRejected.make({
           threadId: validated.checkpoint.threadId,
@@ -696,12 +762,14 @@ const makeServices = Effect.fn("DoThreadStore.makeServices")(function* () {
         });
       }
       const checkpointJson = yield* encodeCheckpoint(validated.checkpoint);
+
       const raw = RawCheckpoint.make({
         threadId: validated.checkpoint.threadId,
         throughSequence: validated.checkpoint.throughSequence,
         tailDigest: validated.checkpoint.tailDigest,
         checkpointJson,
       });
+
       yield* hitFailpoint("save-checkpoint:before");
       yield* journal.saveCheckpoint(raw).pipe(
         Effect.mapError((error) =>
@@ -722,10 +790,13 @@ const makeServices = Effect.fn("DoThreadStore.makeServices")(function* () {
       const validated = yield* Schema.decodeUnknownEffect(Schema.toType(LoadCheckpointRequest))(
         request,
       ).pipe(Effect.mapError((error) => schemaStoreError("validate checkpoint lookup", error)));
+
       const thread = yield* requireThread(journal, validated.threadId);
+
       const rows = yield* journal
         .loadCheckpoint(validated.threadId, validated.atOrBeforeSequence ?? thread.tail_sequence)
         .pipe(Effect.mapError((error) => storeError("load checkpoint", error)));
+
       if (rows.length === 0) return Option.none();
       if (rows.length !== 1) {
         return yield* ThreadStoreError.make({
@@ -734,17 +805,20 @@ const makeServices = Effect.fn("DoThreadStore.makeServices")(function* () {
         });
       }
       const checkpoint = yield* decodeCheckpoint(rows[0].checkpoint_json);
+
       const canonicalDigest = yield* tailDigestAt(
         journal,
         checkpoint.threadId,
         checkpoint.throughSequence,
       );
+
       if (canonicalDigest !== checkpoint.tailDigest) {
         return yield* CheckpointRejected.make({
           threadId: checkpoint.threadId,
           reason: "digest-mismatch",
         });
       }
+
       return Option.some(checkpoint);
     },
   );

package/src/errors.ts

@@ -155,6 +155,7 @@ export const DoStorageFailpointLocation = Schema.Literals([
   "ledger:child-settled:before",
   "ledger:child-settled:after",
 ]);
+
 export type DoStorageFailpointLocation = typeof DoStorageFailpointLocation.Type;
 
 /** Deterministic test-only fault or pause injected at a Durable Object storage boundary. */

package/src/memory-protocol.ts

@@ -60,7 +60,9 @@ const RevalidateRequest = Schema.TaggedStruct("Revalidate", {
   lookup: MemoryLookup,
   limits: MemoryRecallLimits,
 });
+
 const ChangeRequest = Schema.TaggedStruct("Change", { ...RequestFields, write: MemoryWrite.Wire });
+
 const SemanticRequest: Schema.TaggedStruct<
   "RevalidateSemantic",
   typeof RequestFields & {
@@ -74,9 +76,11 @@ const SemanticRequest: Schema.TaggedStruct<
   profile: SemanticMemoryProfile,
   limits: SemanticCandidateLimits,
 });
+
 export const MemoryOwnerRequest: Schema.Union<
   [typeof RevalidateRequest, typeof ChangeRequest, typeof SemanticRequest]
 > = Schema.Union([RevalidateRequest, ChangeRequest, SemanticRequest]);
+
 export type MemoryOwnerRequest = typeof MemoryOwnerRequest.Type;
 
 export const MemoryOwnerFailure = Schema.Union([
@@ -90,6 +94,7 @@ export const MemoryOwnerFailure = Schema.Union([
   MemoryIndexError,
   SemanticMemoryError,
 ]);
+
 export type MemoryOwnerFailure = typeof MemoryOwnerFailure.Type;
 
 export const MemoryOwnerResponse = Schema.Union([
@@ -98,6 +103,7 @@ export const MemoryOwnerResponse = Schema.Union([
   Schema.TaggedStruct("Semantic", { access: MemoryAccess.Wire, result: SemanticCandidateResult }),
   Schema.TaggedStruct("Failed", { failure: MemoryOwnerFailure }),
 ]);
+
 export type MemoryOwnerResponse = typeof MemoryOwnerResponse.Type;
 
 /** Fail-closed application policy. Authorize the namespace, principal, scope, and full command. */
@@ -126,8 +132,10 @@ export const decodeMemoryWire = Effect.fn("decodeMemoryWire")(function* <A, I>(
   const text = yield* Schema.decodeUnknownEffect(Schema.String)(raw).pipe(
     Effect.mapError(() => MemoryRpcError.make({ reason: "protocol" })),
   );
+
   if (text.length > maxBytes || memoryWireBytes(text) > maxBytes)
     return yield* MemoryRpcError.make({ reason: "budget" });
+
   return yield* Schema.decodeEffect(Schema.fromJsonString(schema))(text).pipe(
     Effect.mapError(() => MemoryRpcError.make({ reason: "protocol" })),
   );
@@ -141,8 +149,10 @@ export const encodeMemoryWire = Effect.fn("encodeMemoryWire")(function* <A, I>(
   const encoded = yield* Schema.encodeEffect(Schema.fromJsonString(schema))(value).pipe(
     Effect.mapError(() => MemoryRpcError.make({ reason: "protocol" })),
   );
+
   if (encoded.length > maxBytes || memoryWireBytes(encoded) > maxBytes)
     return yield* MemoryRpcError.make({ reason: "budget" });
+
   return encoded;
 });
 
@@ -165,6 +175,7 @@ export const handleMemoryOwnerRequest = Effect.fn("MemoryOwner.handleRequest")(f
     );
     const request = yield* decodeMemoryWire(MemoryOwnerRequest, raw, limits.maxRequestBytes);
     const { namespace } = yield* MemoryOwnerIdentity;
+
     if (
       !MemoryNamespace.equals(namespace, request.access.namespace) ||
       (request._tag === "Change" &&
@@ -175,20 +186,25 @@ export const handleMemoryOwnerRequest = Effect.fn("MemoryOwner.handleRequest")(f
         ))
     )
       return yield* MemoryRpcError.make({ reason: "denied" });
+
     const remaining = Math.min(
       limits.timeoutMillis,
       request.deadlineMillis - (yield* Clock.currentTimeMillis),
     );
+
     if (remaining <= 0) return yield* MemoryRpcError.make({ reason: "timeout" });
+
     return yield* Effect.gen(function* (): Effect.fn.Return<
       MemoryOwnerResponse,
       MemoryOwnerFailure,
       MemoryOwnerAuthorizer | MemoryReader | MemoryWriter
     > {
       const authorizer = yield* MemoryOwnerAuthorizer;
+
       yield* authorizer.authorize(request);
       if (request._tag === "Change") {
         const writer = yield* MemoryWriter;
+
         return {
           _tag: "Changed",
           access: request.access,
@@ -201,6 +217,7 @@ export const handleMemoryOwnerRequest = Effect.fn("MemoryOwner.handleRequest")(f
           limits.maxSources
         )
           return yield* MemoryRpcError.make({ reason: "budget" });
+
         const result = yield* revalidateSemanticMemoryCandidates(
           request.found,
           request.access,
@@ -217,18 +234,23 @@ export const handleMemoryOwnerRequest = Effect.fn("MemoryOwner.handleRequest")(f
             ),
           },
         );
+
         return { _tag: "Semantic", access: request.access, result };
       }
+
       const count =
         request.lookup._tag === "Found"
           ? new Set(request.lookup.passages.map((passage) => passage.source.id)).size
           : 0;
+
       if (count > Math.min(limits.maxSources, request.limits.maxSources))
         return yield* MemoryRpcError.make({ reason: "budget" });
+
       const lookup = yield* revalidateMemoryLookup(request.lookup, request.access, {
         maxSourceBytes: limits.maxSourceBytes,
         maxInputBytes: Math.min(limits.maxSourceBytes, request.limits.maxInputBytes ?? 16_777_216),
       });
+
       return { _tag: "Lookup", access: request.access, lookup };
     }).pipe(
       Effect.scoped,
@@ -243,7 +265,9 @@ export const handleMemoryOwnerRequest = Effect.fn("MemoryOwner.handleRequest")(f
     ),
     Effect.result,
   );
+
   if (result._tag === "Success") return result.success;
+
   return yield* encodeMemoryWire(
     MemoryOwnerResponse,
     {

package/src/port-protocol.ts

@@ -177,6 +177,7 @@ export const PortRequest = Schema.Union([
   StoreInspectTailCall,
   StoreExportCall,
 ]);
+
 export type PortRequest = typeof PortRequest.Type;
 
 /** The wire form of one port request (what a transport actually carries). */
@@ -264,6 +265,7 @@ export const PortResult = Schema.Union([
   StoreInspectTailResult,
   StoreExportResult,
 ]);
+
 export type PortResult = typeof PortResult.Type;
 
 // ---------------------------------------------------------------------------
@@ -286,6 +288,7 @@ export const PortFailure = Schema.Union([
   FenceRejected,
   PortProtocolError,
 ]);
+
 export type PortFailure = typeof PortFailure.Type;
 
 /** The routed operation succeeded on its owning Object. */