@effect-agent/storage-memory 0.1.0-beta.42 → 0.1.0-beta.44

package/src/memory-schedule-store.ts

@@ -59,7 +59,9 @@ const makeScheduleStore = Effect.gen(function* () {
     (record, ownerLimit) =>
       Effect.gen(function* () {
         const encoded = yield* encodeRecord("insert", record);
+
         yield* failpoint.hit("schedule:insert:before");
+
         const decision = yield* Effect.uninterruptible(
           Ref.modify(
             state,
@@ -74,17 +76,20 @@ const makeScheduleStore = Effect.gen(function* () {
             ] => {
               const key = scheduleKeyString(record);
               const existingText = current.records.get(key);
+
               if (existingText !== undefined) {
                 const decoded = Result.try({
                   try: () => Schema.decodeSync(Schema.fromJsonString(ScheduleRecord))(existingText),
                   catch: () => storageError("insert", "corrupt"),
                 });
+
                 if (Result.isFailure(decoded)) {
                   return [Result.fail(decoded.failure), current];
                 }
                 if (decoded.success.creationFingerprint === record.creationFingerprint) {
                   return [Result.succeed(decoded.success), current];
                 }
+
                 return [
                   Result.fail(
                     ScheduleConflict.make({ reason: "creation", key: scheduleKeyOf(record) }),
@@ -94,11 +99,13 @@ const makeScheduleStore = Effect.gen(function* () {
               }
 
               let ownerCount = 0;
+
               for (const text of current.records.values()) {
                 const decoded = Result.try({
                   try: () => Schema.decodeSync(Schema.fromJsonString(ScheduleRecord))(text),
                   catch: () => storageError("insert", "corrupt"),
                 });
+
                 if (Result.isFailure(decoded)) {
                   return [Result.fail(decoded.failure), current];
                 }
@@ -112,14 +119,19 @@ const makeScheduleStore = Effect.gen(function* () {
                 return [Result.fail(ScheduleCapacityError.make({ limit: ownerLimit })), current];
               }
               const records = new Map(current.records);
+
               records.set(key, encoded);
               const next = { records };
+
               return [Result.succeed(record), next];
             },
           ),
         );
+
         const inserted = yield* Effect.fromResult(decision);
+
         yield* failpoint.hit("schedule:insert:after");
+
         return yield* decodeRecord("insert", yield* encodeRecord("insert", inserted));
       }),
   );
@@ -128,6 +140,7 @@ const makeScheduleStore = Effect.gen(function* () {
     function* (key) {
       const decodedKey = yield* decodeInput("get", ScheduleKey, key);
       const text = (yield* Ref.get(state)).records.get(scheduleKeyString(decodedKey));
+
       return text === undefined ? null : yield* decodeRecord("get", text);
     },
   );
@@ -136,8 +149,10 @@ const makeScheduleStore = Effect.gen(function* () {
     function* (request) {
       const decodedRequest = yield* decodeInput("list", SchedulePageRequest, request);
       const records: Array<ScheduleRecord> = [];
+
       for (const text of (yield* Ref.get(state)).records.values()) {
         const record = yield* decodeRecord("list", text);
+
         if (
           sameOwner(record, decodedRequest.owner) &&
           (decodedRequest.after === undefined ||
@@ -149,6 +164,7 @@ const makeScheduleStore = Effect.gen(function* () {
       records.sort((left, right) => compareScheduleNames(left.scheduleId, right.scheduleId));
       const hasNext = records.length > decodedRequest.limit;
       const items = records.slice(0, decodedRequest.limit);
+
       return {
         items,
         next: hasNext ? (items.at(-1)?.scheduleId ?? null) : null,
@@ -161,7 +177,9 @@ const makeScheduleStore = Effect.gen(function* () {
       Effect.gen(function* () {
         const decodedKey = yield* decodeInput("change", ScheduleKey, key);
         const decodedCommand = yield* decodeInput("change", ScheduleChange, command);
+
         yield* failpoint.hit(`schedule:${decodedCommand._tag.toLowerCase()}:before`);
+
         const decision = yield* Effect.uninterruptible(
           Ref.modify(
             state,
@@ -176,17 +194,21 @@ const makeScheduleStore = Effect.gen(function* () {
             ] => {
               const storageKey = scheduleKeyString(decodedKey);
               const text = current.records.get(storageKey);
+
               if (text === undefined) {
                 return [Result.fail(ScheduleNotFound.make({ key: decodedKey })), current];
               }
+
               const decoded = Result.try({
                 try: () => Schema.decodeSync(Schema.fromJsonString(ScheduleRecord))(text),
                 catch: () => storageError("change", "corrupt"),
               });
+
               if (Result.isFailure(decoded)) {
                 return [Result.fail(decoded.failure), current];
               }
               const applied = applyScheduleChange(decoded.success, decodedCommand);
+
               if (Result.isFailure(applied)) {
                 return [Result.fail(applied.failure), current];
               }
@@ -195,10 +217,12 @@ const makeScheduleStore = Effect.gen(function* () {
               }
               if (!scheduleUsesCapacity(decoded.success) && scheduleUsesCapacity(applied.success)) {
                 let count = 0;
+
                 for (const text of current.records.values()) {
                   const candidate = Schema.decodeUnknownResult(
                     Schema.fromJsonString(ScheduleRecord),
                   )(text);
+
                   if (Result.isFailure(candidate))
                     return [Result.fail(storageError("change", "corrupt")), current];
                   if (
@@ -210,23 +234,30 @@ const makeScheduleStore = Effect.gen(function* () {
                 if (count >= ownerLimit)
                   return [Result.fail(ScheduleCapacityError.make({ limit: ownerLimit })), current];
               }
+
               const encoded = Result.try({
                 try: () =>
                   Schema.encodeSync(Schema.fromJsonString(ScheduleRecord))(applied.success),
                 catch: () => storageError("change", "corrupt"),
               });
+
               if (Result.isFailure(encoded)) {
                 return [Result.fail(encoded.failure), current];
               }
               const records = new Map(current.records);
+
               records.set(storageKey, encoded.success);
               const next = { records };
+
               return [Result.succeed(applied.success), next];
             },
           ),
         );
+
         const changed = yield* Effect.fromResult(decision);
+
         yield* failpoint.hit(`schedule:${decodedCommand._tag.toLowerCase()}:after`);
+
         return yield* decodeRecord("change", yield* encodeRecord("change", changed));
       }),
   );
@@ -235,12 +266,16 @@ const makeScheduleStore = Effect.gen(function* () {
     function* (nowMillis, limit, owner, after) {
       const decodedOwner =
         owner === undefined ? undefined : yield* decodeInput("due", ScheduleOwner, owner);
+
       const cursor =
         after === undefined ? undefined : yield* decodeInput("due", ScheduleDueCursor, after);
+
       const records: Array<ScheduleDueCursor> = [];
+
       for (const text of (yield* Ref.get(state)).records.values()) {
         const record = yield* decodeRecord("due", text);
         const deadline = scheduleDeadline(record);
+
         if (
           deadline !== null &&
           deadline <= nowMillis &&
@@ -254,8 +289,10 @@ const makeScheduleStore = Effect.gen(function* () {
       }
       records.sort((left, right) => {
         const byDeadline = left.deadlineAtMillis - right.deadlineAtMillis;
+
         return byDeadline !== 0 ? byDeadline : compareScheduleKeys(left, right);
       });
+
       return records.slice(0, limit);
     },
   );
@@ -265,13 +302,18 @@ const makeScheduleStore = Effect.gen(function* () {
   )(function* (owner) {
     const decodedOwner =
       owner === undefined ? undefined : yield* decodeInput("nextDeadline", ScheduleOwner, owner);
+
     let earliest: number | null = null;
+
     for (const text of (yield* Ref.get(state)).records.values()) {
       const record = yield* decodeRecord("nextDeadline", text);
+
       if (decodedOwner !== undefined && !sameOwner(record, decodedOwner)) continue;
       const deadline = scheduleDeadline(record);
+
       if (deadline !== null && (earliest === null || deadline < earliest)) earliest = deadline;
     }
+
     return earliest;
   });
 

package/src/memory-storage.ts

@@ -104,10 +104,12 @@ const offsetSequence = Effect.fn("MemoryThreadStore.offsetSequence")((
   if (offset === undefined) return Effect.succeed(ZERO_CANONICAL_SEQUENCE);
   const prefix = `memory:v1:${Encoding.encodeBase64(threadId)}:`;
   const encodedSequence = offset.startsWith(prefix) ? offset.slice(prefix.length) : "";
+
   if (!/^\d+$/.test(encodedSequence)) {
     return Effect.fail(storeError("observe", "Malformed observation offset"));
   }
   const sequence = Number(encodedSequence);
+
   return Number.isSafeInteger(sequence)
     ? Schema.decodeUnknownEffect(CanonicalSequence)(sequence).pipe(
         Effect.mapError(() => storeError("observe", "Malformed observation offset")),
@@ -123,6 +125,7 @@ const findThread = Effect.fn("MemoryThreadStore.findThread")((
   threadId: ThreadId,
 ): Effect.Effect<StoredThread, ThreadNotMaterialized> => {
   const thread = state.threads.get(threadId);
+
   return thread === undefined
     ? Effect.fail(ThreadNotMaterialized.make({ threadId }))
     : Effect.succeed(thread);
@@ -140,6 +143,7 @@ const validateCheckpointVersion = Effect.fn("MemoryThreadStore.validateCheckpoin
     const envelope = yield* Schema.decodeUnknownEffect(CheckpointVersionEnvelope)(value).pipe(
       Effect.mapError(() => storeError("saveCheckpoint", "Invalid saveCheckpoint request")),
     );
+
     if (envelope.checkpoint.schemaVersion !== 1) {
       return yield* CheckpointRejected.make({
         threadId: envelope.checkpoint.threadId,
@@ -153,6 +157,7 @@ const makeThreadStore = Effect.gen(function* () {
   const crypto = yield* Crypto.Crypto;
   const state = yield* Ref.make<MemoryState>({ threads: new Map() });
   const updates = yield* PubSub.sliding<void>(1);
+
   yield* Effect.addFinalizer(() => PubSub.shutdown(updates));
 
   const materialize: ThreadStore["Service"]["materialize"] = Effect.fn(
@@ -160,10 +165,12 @@ const makeThreadStore = Effect.gen(function* () {
   )((unvalidated) =>
     Effect.gen(function* () {
       const request = yield* validate(ThreadMaterialization, "materialize", unvalidated);
+
       const decision = yield* Ref.modify(
         state,
         (current): readonly [MaterializeDecision, MemoryState] => {
           const existing = current.threads.get(request.threadId);
+
           if (existing !== undefined) {
             if (request.producerEpoch < existing.producerEpoch) {
               return [
@@ -182,10 +189,12 @@ const makeThreadStore = Effect.gen(function* () {
               return [{ _tag: "success" }, current];
             }
             const threads = new Map(current.threads);
+
             threads.set(request.threadId, {
               ...existing,
               producerEpoch: request.producerEpoch,
             });
+
             return [{ _tag: "success" }, { threads }];
           }
           if (current.threads.size >= MAX_THREADS) {
@@ -198,6 +207,7 @@ const makeThreadStore = Effect.gen(function* () {
             ];
           }
           const threads = new Map(current.threads);
+
           threads.set(request.threadId, {
             producerEpoch: request.producerEpoch,
             tailSequence: ZERO_CANONICAL_SEQUENCE,
@@ -208,9 +218,11 @@ const makeThreadStore = Effect.gen(function* () {
             tailDigests: new Map([[ZERO_CANONICAL_SEQUENCE, EMPTY_TAIL_DIGEST]]),
             checkpoints: new Map(),
           });
+
           return [{ _tag: "success" }, { threads }];
         },
       );
+
       if (decision._tag === "failure") return yield* decision.error;
     }),
   );
@@ -219,6 +231,7 @@ const makeThreadStore = Effect.gen(function* () {
     (unvalidated) =>
       Effect.gen(function* () {
         const request = yield* validate(FencedAppendRequest, "append", unvalidated);
+
         const digest = yield* digestCanonicalBatch(request.expectedTailDigest, request.batch).pipe(
           Effect.provideService(Crypto.Crypto, crypto),
           Effect.mapError((error) => storeError("append", error.message, error)),
@@ -227,6 +240,7 @@ const makeThreadStore = Effect.gen(function* () {
         const decision = yield* Effect.uninterruptible(
           Ref.modify(state, (current): readonly [AppendDecision, MemoryState] => {
             const thread = current.threads.get(request.threadId);
+
             if (thread === undefined) {
               return [
                 {
@@ -252,6 +266,7 @@ const makeThreadStore = Effect.gen(function* () {
               ];
             }
             const previous = thread.batches.get(request.batch.batchId);
+
             if (previous !== undefined) {
               if (previous.digest !== digest) {
                 return [
@@ -266,6 +281,7 @@ const makeThreadStore = Effect.gen(function* () {
                   current,
                 ];
               }
+
               return [
                 {
                   _tag: "success",
@@ -312,6 +328,7 @@ const makeThreadStore = Effect.gen(function* () {
             }
 
             const batchRecordIds = new Set<RecordId>();
+
             for (const record of request.batch.records) {
               if (thread.recordIds.has(record.recordId) || batchRecordIds.has(record.recordId)) {
                 return [
@@ -331,6 +348,7 @@ const makeThreadStore = Effect.gen(function* () {
 
             const records = request.batch.records.map((record, index) => {
               const sequence = decodeCanonicalSequence(thread.tailSequence + index + 1);
+
               return CanonicalRecordEnvelope.make({
                 threadId: request.threadId,
                 batchId: request.batch.batchId,
@@ -339,20 +357,27 @@ const makeThreadStore = Effect.gen(function* () {
                 record,
               });
             });
+
             const lastSequence = decodeCanonicalSequence(thread.tailSequence + records.length);
+
             const result = AppendResult.make({
               firstSequence: decodeCanonicalSequence(thread.tailSequence + 1),
               lastSequence,
               tailDigest: digest,
               replayed: false,
             });
+
             const batches = new Map(thread.batches);
+
             batches.set(request.batch.batchId, { digest, result });
             const recordIds = new Set(thread.recordIds);
+
             for (const recordId of batchRecordIds) recordIds.add(recordId);
             const tailDigests = new Map(thread.tailDigests);
+
             tailDigests.set(lastSequence, digest);
             const threads = new Map(current.threads);
+
             threads.set(request.threadId, {
               ...thread,
               tailSequence: lastSequence,
@@ -362,6 +387,7 @@ const makeThreadStore = Effect.gen(function* () {
               batches,
               tailDigests,
             });
+
             return [{ _tag: "success", result, records }, { threads }];
           }).pipe(
             Effect.tap((decision) =>
@@ -371,7 +397,9 @@ const makeThreadStore = Effect.gen(function* () {
             ),
           ),
         );
+
         if (decision._tag === "failure") return yield* decision.error;
+
         return decision.result;
       }),
   );
@@ -393,6 +421,7 @@ const makeThreadStore = Effect.gen(function* () {
       Effect.gen(function* () {
         const request = yield* validate(ThreadRead, "read", unvalidated);
         const records = yield* readSnapshot(request.threadId, request.afterSequence, request.limit);
+
         return Stream.fromIterable(records);
       }),
     );
@@ -402,16 +431,20 @@ const makeThreadStore = Effect.gen(function* () {
       Effect.gen(function* () {
         const request = yield* validate(ThreadObservation, "observe", unvalidated);
         const afterSequence = yield* offsetSequence(request.threadId, request.afterOffset);
+
         return Stream.unwrap(
           Effect.gen(function* () {
             const subscription = yield* PubSub.subscribe(updates);
+
             const initial = yield* readSnapshot(
               request.threadId,
               afterSequence,
               MAX_RECORDS_PER_THREAD,
             );
+
             const highWater =
               initial.length === 0 ? afterSequence : (initial.at(-1)?.sequence ?? afterSequence);
+
             const live = Stream.fromEffectRepeat(PubSub.take(subscription)).pipe(
               Stream.mapAccumEffect(
                 () => highWater,
@@ -423,6 +456,7 @@ const makeThreadStore = Effect.gen(function* () {
                   ),
               ),
             );
+
             return Stream.fromIterable(initial).pipe(Stream.concat(live));
           }),
         );
@@ -433,9 +467,11 @@ const makeThreadStore = Effect.gen(function* () {
     (unvalidated) =>
       Effect.gen(function* () {
         const request = yield* validate(ThreadExportRequest, "export", unvalidated);
+
         const thread = yield* Ref.get(state).pipe(
           Effect.flatMap((current) => findThread(current, request.threadId)),
         );
+
         return ThreadExport.make({
           format: "effect-agent/thread@1",
           threadId: request.threadId,
@@ -451,9 +487,11 @@ const makeThreadStore = Effect.gen(function* () {
   )((unvalidated) =>
     Effect.gen(function* () {
       const request = yield* validate(ThreadTailRequest, "inspectTail", unvalidated);
+
       const thread = yield* Ref.get(state).pipe(
         Effect.flatMap((current) => findThread(current, request.threadId)),
       );
+
       return ThreadTail.make({
         threadId: request.threadId,
         tailSequence: thread.tailSequence,
@@ -468,11 +506,13 @@ const makeThreadStore = Effect.gen(function* () {
       Effect.gen(function* () {
         yield* validateCheckpointVersion(unvalidated);
         const request = yield* validate(SaveCheckpointRequest, "saveCheckpoint", unvalidated);
+
         const decision = yield* Ref.modify(
           state,
           (current): readonly [CheckpointDecision, MemoryState] => {
             const checkpoint = request.checkpoint;
             const thread = current.threads.get(checkpoint.threadId);
+
             if (thread === undefined) {
               return [
                 {
@@ -524,12 +564,16 @@ const makeThreadStore = Effect.gen(function* () {
               ];
             }
             const checkpoints = new Map(thread.checkpoints);
+
             checkpoints.set(checkpoint.throughSequence, checkpoint);
             const threads = new Map(current.threads);
+
             threads.set(checkpoint.threadId, { ...thread, checkpoints });
+
             return [{ _tag: "success" }, { threads }];
           },
         );
+
         if (decision._tag === "failure") return yield* decision.error;
       }),
   );
@@ -538,11 +582,14 @@ const makeThreadStore = Effect.gen(function* () {
     (unvalidated) =>
       Effect.gen(function* () {
         const request = yield* validate(LoadCheckpointRequest, "loadCheckpoint", unvalidated);
+
         const thread = yield* Ref.get(state).pipe(
           Effect.flatMap((current) => findThread(current, request.threadId)),
         );
+
         const maximum = request.atOrBeforeSequence ?? thread.tailSequence;
         let selected: ThreadCheckpoint | undefined;
+
         for (const [sequence, checkpoint] of thread.checkpoints) {
           if (
             sequence <= maximum &&
@@ -560,6 +607,7 @@ const makeThreadStore = Effect.gen(function* () {
             reason: "digest-mismatch",
           });
         }
+
         return Option.fromNullishOr(selected);
       }),
   );