@effect-agent/storage-memory 0.1.0-beta.56 → 0.1.0-beta.58

package/src/MemorySubmissionLedger.ts

@@ -7,8 +7,10 @@ import {
   type ThreadId,
   type SettlementId,
 } from "@effect-agent/core/Identifiers";
+import { MessageAdmission } from "@effect-agent/core/Messaging";
 import {
   PersistedJson,
+  WorkerAdmission,
   ProducerEpoch,
   type DefinitionDigests,
   type DeploymentId,
@@ -147,6 +149,8 @@ interface SubmissionRow {
   readonly parentLinkage: ParentLinkage | undefined;
   readonly admissionGroup?: string;
   readonly admissionFence?: AdmissionRequest["admissionFence"];
+  readonly workerAdmissionJson?: string;
+  readonly messageAdmissionJson?: string;
 }
 
 interface StoredOwnership {
@@ -290,6 +294,20 @@ const toSnapshot = (row: SubmissionRow): SubmissionSnapshot =>
     createdAt: utc(row.createdAtMillis),
     ...(row.admissionGroup === undefined ? {} : { admissionGroup: row.admissionGroup }),
     ...(row.admissionFence === undefined ? {} : { admissionFence: row.admissionFence }),
+    ...(row.workerAdmissionJson === undefined
+      ? {}
+      : {
+          workerAdmission: Schema.decodeSync(Schema.fromJsonString(WorkerAdmission))(
+            row.workerAdmissionJson,
+          ),
+        }),
+    ...(row.messageAdmissionJson === undefined
+      ? {}
+      : {
+          messageAdmission: Schema.decodeSync(Schema.fromJsonString(MessageAdmission))(
+            row.messageAdmissionJson,
+          ),
+        }),
     ...(row.settledOutcome === undefined ? {} : { settledOutcome: row.settledOutcome }),
     ...(row.readyAtMillis === undefined ? {} : { readyAt: utc(row.readyAtMillis) }),
     ...(row.parentLinkage === undefined ? {} : { parentLinkage: row.parentLinkage }),
@@ -414,6 +432,24 @@ const makeSubmissionLedger = (options: MemorySubmissionLedgerOptions = {}) =>
         Effect.gen(function* () {
           const request = yield* validate(AdmissionRequest, "admit", unvalidated);
 
+          const workerAdmissionJson =
+            request.workerAdmission === undefined
+              ? undefined
+              : yield* Schema.encodeEffect(Schema.fromJsonString(WorkerAdmission))(
+                  request.workerAdmission,
+                ).pipe(
+                  Effect.mapError(() => ledgerError("admit", "Invalid worker admission metadata")),
+                );
+
+          const messageAdmissionJson =
+            request.messageAdmission === undefined
+              ? undefined
+              : yield* Schema.encodeEffect(Schema.fromJsonString(MessageAdmission))(
+                  request.messageAdmission,
+                ).pipe(
+                  Effect.mapError(() => ledgerError("admit", "Invalid message admission metadata")),
+                );
+
           const nowMillis = yield* Clock.currentTimeMillis;
           const services = yield* Effect.context<never>();
 
@@ -448,6 +484,22 @@ const makeSubmissionLedger = (options: MemorySubmissionLedgerOptions = {}) =>
                   existing.row.inputDigest !== request.inputDigest ||
                   !sameParentLinkage(existing.row.parentLinkage, request.parentLinkage) ||
                   existing.row.admissionGroup !== request.admissionGroup ||
+                  !Schema.toEquivalence(Schema.optional(WorkerAdmission))(
+                    existing.row.workerAdmissionJson === undefined
+                      ? undefined
+                      : Schema.decodeSync(Schema.fromJsonString(WorkerAdmission))(
+                          existing.row.workerAdmissionJson,
+                        ),
+                    request.workerAdmission,
+                  ) ||
+                  !Schema.toEquivalence(Schema.optional(MessageAdmission))(
+                    existing.row.messageAdmissionJson === undefined
+                      ? undefined
+                      : Schema.decodeSync(Schema.fromJsonString(MessageAdmission))(
+                          existing.row.messageAdmissionJson,
+                        ),
+                    request.messageAdmission,
+                  ) ||
                   !Schema.toEquivalence(Schema.optional(Schema.Json))(
                     existing.row.admissionFence,
                     request.admissionFence,
@@ -480,6 +532,36 @@ const makeSubmissionLedger = (options: MemorySubmissionLedgerOptions = {}) =>
                   current,
                 ];
               }
+
+              // A Thread's first admission fixes its worker origin before canonical materialization.
+              const first = [...current.submissions.values()].find(
+                ({ row }) => row.threadId === request.threadId,
+              );
+
+              if (first !== undefined) {
+                const previous =
+                  first.row.workerAdmissionJson === undefined
+                    ? undefined
+                    : Schema.decodeSync(Schema.fromJsonString(WorkerAdmission))(
+                        first.row.workerAdmissionJson,
+                      );
+
+                if (
+                  !Schema.toEquivalence(Schema.optional(WorkerAdmission.fields.origin))(
+                    previous?.origin,
+                    request.workerAdmission?.origin,
+                  )
+                )
+                  return [
+                    failure(
+                      AdmissionPolicyError.make({
+                        reason: "refused",
+                        code: "worker-origin-conflict",
+                      }),
+                    ),
+                    current,
+                  ];
+              }
               // A memory policy and the ledger mutation share one synchronous critical section.
               // An asynchronous policy cannot fence this Ref and therefore fails closed.
               const checked = Effect.runSyncExitWith(services)(admissionFence.check(request));
@@ -535,6 +617,8 @@ const makeSubmissionLedger = (options: MemorySubmissionLedgerOptions = {}) =>
                 createdAtMillis: nowMillis,
                 readyAtMillis: undefined,
                 parentLinkage: request.parentLinkage,
+                ...(workerAdmissionJson === undefined ? {} : { workerAdmissionJson }),
+                ...(messageAdmissionJson === undefined ? {} : { messageAdmissionJson }),
                 ...(request.admissionGroup === undefined
                   ? {}
                   : { admissionGroup: request.admissionGroup }),

package/src/MemoryThreadStore.ts

@@ -30,12 +30,28 @@ import {
   LoadCheckpointRequest,
   SaveCheckpointRequest,
 } from "@effect-agent/thread/ThreadStore";
-import { Crypto, Effect, Encoding, Layer, Option, PubSub, Ref, Schema, Stream } from "effect";
+import {
+  Context,
+  Crypto,
+  Effect,
+  Encoding,
+  Layer,
+  Option,
+  PubSub,
+  Ref,
+  Schema,
+  Stream,
+} from "effect";
 
 const MAX_THREADS = 256;
 const MAX_RECORDS_PER_THREAD = 65_536;
 const MAX_CHECKPOINTS_PER_THREAD = 1_024;
 
+const ThreadCapacity = Context.Reference<number>(
+  "@effect-agent/storage-memory/MemoryThreadStore/ThreadCapacity",
+  { defaultValue: () => MAX_THREADS },
+);
+
 interface StoredBatch {
   readonly digest: Digest;
   readonly result: AppendResult;
@@ -155,6 +171,7 @@ const validateCheckpointVersion = Effect.fn("MemoryThreadStore.validateCheckpoin
 );
 
 const makeThreadStore = Effect.gen(function* () {
+  const maxThreads = yield* ThreadCapacity;
   const crypto = yield* Crypto.Crypto;
   const state = yield* Ref.make<MemoryState>({ threads: new Map() });
   const updates = yield* PubSub.sliding<void>(1);
@@ -198,11 +215,11 @@ const makeThreadStore = Effect.gen(function* () {
 
             return [{ _tag: "success" }, { threads }];
           }
-          if (current.threads.size >= MAX_THREADS) {
+          if (current.threads.size >= maxThreads) {
             return [
               {
                 _tag: "failure",
-                error: storeError("materialize", `In-memory thread limit ${MAX_THREADS} exceeded`),
+                error: storeError("materialize", `In-memory thread limit ${maxThreads} exceeded`),
               },
               current,
             ];
@@ -630,3 +647,15 @@ const makeThreadStore = Effect.gen(function* () {
  * SubmissionLedger port; this Layer deliberately provides only the ThreadStore.
  */
 export const MemoryThreadStoreLive = Layer.effect(ThreadStore, makeThreadStore);
+
+/** Configure a finite retained Thread capacity. Invalid construction options throw immediately. */
+export const memoryThreadStoreLayer = (options: { readonly maxThreads?: number } = {}) =>
+  MemoryThreadStoreLive.pipe(
+    Layer.provide(
+      Layer.succeed(ThreadCapacity)(
+        Schema.decodeSync(
+          Schema.Int.check(Schema.isGreaterThan(0), Schema.isLessThanOrEqualTo(65_536)),
+        )(options.maxThreads ?? MAX_THREADS),
+      ),
+    ),
+  );

package/src/index.ts

@@ -1,4 +1,5 @@
 export * as MemoryScheduleStore from "./MemoryScheduleStore.ts";
+export * as MemoryMessageDeliveryStore from "./MemoryMessageDeliveryStore.ts";
 export * as MemorySemanticIndex from "./MemorySemanticIndex.ts";
 export * as MemorySubmissionLedger from "./MemorySubmissionLedger.ts";
 export * as MemorySubscriptionStore from "./MemorySubscriptionStore.ts";