@effect-agent/storage-memory 0.1.0-beta.13 → 0.1.0-beta.130

package/dist/rolldown-runtime-D7D4PA-g.mjs

@@ -0,0 +1,13 @@
+//#region \0rolldown/runtime.js
+var __defProp = Object.defineProperty;
+var __exportAll = (all, no_symbols) => {
+	let target = {};
+	for (var name in all) __defProp(target, name, {
+		get: all[name],
+		enumerable: true
+	});
+	if (!no_symbols) __defProp(target, Symbol.toStringTag, { value: "Module" });
+	return target;
+};
+//#endregion
+export { __exportAll as t };

package/package.json

@@ -1,45 +1 @@
-{
-  "name": "@effect-agent/storage-memory",
-  "version": "0.1.0-beta.13",
-  "exports": {
-    ".": {
-      "types": "./dist/index.d.mts",
-      "default": "./dist/index.mjs"
-    },
-    "./testing": {
-      "types": "./dist/testing.d.mts",
-      "default": "./dist/testing.mjs"
-    }
-  },
-  "dependencies": {
-    "@effect-agent/core": "0.1.0-beta.13",
-    "@effect-agent/session": "0.1.0-beta.13",
-    "effect": "4.0.0-beta.107"
-  },
-  "description": "In-memory Conversation store and submission ledger reference adapters for Effect Agent tests and conformance suites.",
-  "license": "MIT",
-  "repository": {
-    "type": "git",
-    "url": "git+https://github.com/danieljvdm/effect-agent.git",
-    "directory": "packages/storage-memory"
-  },
-  "files": [
-    "dist",
-    "src"
-  ],
-  "type": "module",
-  "publishConfig": {
-    "access": "public"
-  },
-  "scripts": {
-    "build": "vp pack",
-    "check": "tsc --noEmit -p tsconfig.json",
-    "test": "vp test --passWithNoTests"
-  },
-  "devDependencies": {
-    "@effect/platform-node": "4.0.0-beta.107",
-    "@effect/vitest": "4.0.0-beta.107",
-    "typescript": "7.0.2",
-    "vite-plus": "0.2.6"
-  }
-}
+{"name":"@effect-agent/storage-memory","version":"0.1.0-beta.130","dependencies":{"effect-agent":"0.1.0-beta.130"},"devDependencies":{"@effect/platform-node":"4.0.0-rc.116","@effect/vitest":"4.0.0-rc.116","effect":"4.0.0-rc.116","typescript":"7.0.2","vite-plus":"0.3.2"},"peerDependencies":{"effect":"^4.0.0-rc.116"},"exports":{".":{"types":"./dist/index.d.mts","default":"./dist/index.mjs"},"./memory-message-delivery-store":{"types":"./dist/MemoryMessageDeliveryStore.d.mts","default":"./dist/MemoryMessageDeliveryStore.mjs"},"./memory-schedule-store":{"types":"./dist/MemoryScheduleStore.d.mts","default":"./dist/MemoryScheduleStore.mjs"},"./memory-semantic-index":{"types":"./dist/MemorySemanticIndex.d.mts","default":"./dist/MemorySemanticIndex.mjs"},"./memory-submission-ledger":{"types":"./dist/MemorySubmissionLedger.d.mts","default":"./dist/MemorySubmissionLedger.mjs"},"./memory-subscription-store":{"types":"./dist/MemorySubscriptionStore.d.mts","default":"./dist/MemorySubscriptionStore.mjs"},"./memory-thread-store":{"types":"./dist/MemoryThreadStore.d.mts","default":"./dist/MemoryThreadStore.mjs"}},"description":"In-memory Thread store and submission ledger reference adapters for Effect Agent tests and conformance suites.","license":"MIT","repository":{"type":"git","url":"git+https://github.com/danieljvdm/effect-agent.git","directory":"packages/storage-memory"},"files":["dist","src"],"type":"module","sideEffects":[],"publishConfig":{"access":"public"},"scripts":{"build":"vp pack","check":"tsc --noEmit -p tsconfig.json","test":"vp test --passWithNoTests"}}

package/src/MemoryMessageDeliveryStore.ts

@@ -0,0 +1,373 @@
+import { Effect, Layer, Ref, Schema, Semaphore } from "effect";
+import { ThreadId } from "effect-agent/identifiers";
+import {
+  applyMessageDeliveryChange,
+  defaultMessageDeliveryStoreLimits,
+  MessageDeliveryChange,
+  MessageDeliveryError,
+  MessageDeliveryFailpoint,
+  MessageDeliveryKey,
+  MessageDeliveryPageRequest,
+  MessageDeliveryRecord,
+  MessageDeliveryStore,
+  MessageDeliveryStoreLimits,
+  messageDeliveryDeadline,
+  messageDeliveryKeyString,
+  messageDeliveryUsesCapacity,
+  isWorkerUpdateDelivery,
+  messageDeliveryCapacity,
+  sameMessageDeliveryIdentity,
+  validateMessageDelivery,
+} from "effect-agent/message-delivery";
+import { ScheduleInstant } from "effect-agent/schedule";
+
+const codec = Schema.fromJsonString(MessageDeliveryRecord);
+
+const decode = (text: string) =>
+  Schema.decodeEffect(codec)(text).pipe(
+    Effect.mapError(() => MessageDeliveryError.make({ reason: "corrupt", operation: "decode" })),
+  );
+
+const Scan = Schema.Struct({
+  nowMillis: ScheduleInstant,
+  limit: Schema.Int.check(Schema.isGreaterThan(0), Schema.isLessThanOrEqualTo(100)),
+  ownerThreadId: Schema.optionalKey(ThreadId),
+});
+
+export interface MemoryMessageDeliveryStoreOptions {
+  /** UTF-8 bound on the complete stored record, including a processed Settlement. */
+  readonly maxStoredValueBytes?: number;
+}
+
+/** Reference adapter. All retained rows are bounded; completed deduplication evidence is never evicted. */
+export const memoryMessageDeliveryStoreLayer = (
+  limits: MessageDeliveryStoreLimits = defaultMessageDeliveryStoreLimits,
+  options: MemoryMessageDeliveryStoreOptions = {},
+): Layer.Layer<MessageDeliveryStore, MessageDeliveryError> =>
+  Layer.effect(
+    MessageDeliveryStore,
+    Effect.gen(function* () {
+      const config = yield* validateMessageDelivery(MessageDeliveryStoreLimits, limits, "limits");
+
+      const maxStoredValueBytes = yield* validateMessageDelivery(
+        Schema.Int.check(Schema.isGreaterThan(0)),
+        options.maxStoredValueBytes ?? 16 * 1_024 * 1_024,
+        "stored-value-limit",
+      );
+
+      const state = yield* Ref.make({
+        records: new Map<string, string>(),
+        pending: new Map<ThreadId, ReadonlySet<MessageDeliveryKey["messageId"]>>(),
+        workers: new Map<string, ReadonlySet<MessageDeliveryKey["messageId"]>>(),
+      });
+
+      const commit = (record: MessageDeliveryRecord, encoded: string) =>
+        Ref.update(state, (current) => {
+          const key = messageDeliveryKeyString(record.key);
+          const keys = new Set(current.pending.get(record.key.ownerThreadId));
+
+          if (messageDeliveryUsesCapacity(record)) keys.add(record.key.messageId);
+          else keys.delete(record.key.messageId);
+          const pending = new Map(current.pending);
+
+          if (keys.size === 0) pending.delete(record.key.ownerThreadId);
+          else pending.set(record.key.ownerThreadId, keys);
+
+          const workers = new Map(current.workers);
+          const admission = record.envelope.workerAdmission;
+
+          if (admission !== undefined) {
+            const worker = admission.origin.worker;
+
+            const startKey = JSON.stringify([
+              record.key.ownerThreadId,
+              worker.delegationId,
+              worker.targetAgentId,
+            ]);
+
+            if (record.key.messageId === admission.origin.firstMessageId)
+              workers.set(
+                startKey,
+                new Set([...(workers.get(startKey) ?? []), record.key.messageId]),
+              );
+            const pendingKey = JSON.stringify([record.key.ownerThreadId, worker.threadId]);
+            const inputs = new Set(workers.get(pendingKey));
+
+            if (
+              (record.status === "pending" || record.status === "parked") &&
+              record.receipt === null
+            )
+              inputs.add(record.key.messageId);
+            else inputs.delete(record.key.messageId);
+            workers.set(pendingKey, inputs);
+          }
+
+          return { records: new Map(current.records).set(key, encoded), pending, workers };
+        });
+
+      const lock = yield* Semaphore.make(1);
+      const failpoint = yield* MessageDeliveryFailpoint;
+
+      const encode = Effect.fn("MemoryMessageDeliveryStore.encode")(function* (
+        record: MessageDeliveryRecord,
+      ) {
+        const text = yield* Schema.encodeEffect(codec)(record).pipe(
+          Effect.mapError(() =>
+            MessageDeliveryError.make({ reason: "corrupt", operation: "encode" }),
+          ),
+        );
+
+        if (new TextEncoder().encode(text).byteLength > maxStoredValueBytes) {
+          return yield* MessageDeliveryError.make({
+            reason: "capacity",
+            operation: "stored-value-bytes",
+          });
+        }
+
+        return text;
+      });
+
+      const all = Effect.fn("MemoryMessageDeliveryStore.all")(function* () {
+        return yield* Effect.forEach((yield* Ref.get(state)).records.values(), decode);
+      });
+
+      const insert: MessageDeliveryStore["Service"]["insert"] = Effect.fn(
+        "MemoryMessageDeliveryStore.insert",
+      )(function* (record) {
+        const encoded = yield* encode(record);
+        const input = yield* decode(encoded);
+
+        if (
+          input.version !== 1 ||
+          input.status !== "pending" ||
+          input.leaseUntilMillis !== null ||
+          input.retry.attempts !== 0 ||
+          input.retry.generation !== 0 ||
+          input.retry.automaticAttempts !== 0 ||
+          input.retry.nextAttemptAtMillis !== input.createdAtMillis ||
+          input.retry.lastAttemptAtMillis !== null ||
+          input.retry.lastFailure !== null ||
+          input.deadlineAtMillis !== input.initialDeadlineAtMillis
+        ) {
+          return yield* MessageDeliveryError.make({
+            reason: "validation",
+            operation: "insert-state",
+          });
+        }
+        if (
+          new TextEncoder().encode(JSON.stringify(input.envelope)).byteLength >
+          config.maxEnvelopeBytes
+        ) {
+          return yield* MessageDeliveryError.make({
+            reason: "capacity",
+            operation: "envelope-bytes",
+          });
+        }
+        yield* failpoint.hit("message-delivery:insert:before");
+
+        const inserted = yield* lock.withPermit(
+          Effect.uninterruptible(
+            Effect.gen(function* () {
+              const { records } = yield* Ref.get(state);
+              const key = messageDeliveryKeyString(input.key);
+              const existingText = records.get(key);
+
+              if (existingText !== undefined) {
+                const existing = yield* decode(existingText);
+
+                if (!sameMessageDeliveryIdentity(existing, input))
+                  return yield* MessageDeliveryError.make({
+                    reason: "conflict",
+                    operation: "insert",
+                  });
+
+                return existing;
+              }
+
+              const owned = (yield* all()).filter(
+                (record) =>
+                  record.key.ownerThreadId === input.key.ownerThreadId &&
+                  isWorkerUpdateDelivery(record) === isWorkerUpdateDelivery(input),
+              );
+
+              const capacity = messageDeliveryCapacity(config, isWorkerUpdateDelivery(input));
+
+              if (
+                owned.length >= capacity.retained ||
+                owned.filter(messageDeliveryUsesCapacity).length >= capacity.pending
+              ) {
+                return yield* MessageDeliveryError.make({
+                  reason: "capacity",
+                  operation: "insert",
+                });
+              }
+              yield* commit(input, encoded);
+
+              return input;
+            }),
+          ),
+        );
+
+        yield* failpoint.hit("message-delivery:insert:after");
+
+        return yield* decode(yield* encode(inserted));
+      });
+
+      const get: MessageDeliveryStore["Service"]["get"] = Effect.fn(
+        "MemoryMessageDeliveryStore.get",
+      )(function* (key) {
+        const input = yield* validateMessageDelivery(MessageDeliveryKey, key, "get");
+        const text = (yield* Ref.get(state)).records.get(messageDeliveryKeyString(input));
+
+        return text === undefined ? null : yield* decode(text);
+      });
+
+      const change: MessageDeliveryStore["Service"]["change"] = Effect.fn(
+        "MemoryMessageDeliveryStore.change",
+      )(function* (key, change) {
+        const input = yield* validateMessageDelivery(MessageDeliveryChange, change, "change");
+        const decodedKey = yield* validateMessageDelivery(MessageDeliveryKey, key, "change");
+        const point = `message-delivery:${input._tag.toLowerCase()}`;
+
+        yield* failpoint.hit(`${point}:before`);
+
+        const changed = yield* lock.withPermit(
+          Effect.uninterruptible(
+            Effect.gen(function* () {
+              const existing = yield* get(decodedKey);
+
+              if (existing === null)
+                return yield* MessageDeliveryError.make({
+                  reason: "not-found",
+                  operation: "change",
+                });
+              const next = yield* Effect.fromResult(applyMessageDeliveryChange(existing, input));
+              const encoded = yield* encode(next);
+
+              yield* commit(next, encoded);
+
+              return next;
+            }),
+          ),
+        );
+
+        yield* failpoint.hit(`${point}:after`);
+
+        return yield* decode(yield* encode(changed));
+      });
+
+      return MessageDeliveryStore.of({
+        limits: config,
+        maxStoredValueBytes,
+        insert,
+        get,
+        change,
+        list: Effect.fn("MemoryMessageDeliveryStore.list")(function* (request) {
+          const input = yield* validateMessageDelivery(MessageDeliveryPageRequest, request, "list");
+
+          const current = yield* Ref.get(state);
+
+          const workerKey =
+            input.workerStarts !== undefined
+              ? JSON.stringify([
+                  input.ownerThreadId,
+                  input.workerStarts.delegationId,
+                  input.workerStarts.targetAgentId,
+                ])
+              : input.pendingWorker !== undefined
+                ? JSON.stringify([input.ownerThreadId, input.pendingWorker])
+                : undefined;
+
+          const retained =
+            workerKey !== undefined || input.pendingOnly
+              ? yield* Effect.forEach(
+                  [
+                    ...((workerKey === undefined
+                      ? current.pending.get(input.ownerThreadId)
+                      : current.workers.get(workerKey)) ?? []),
+                  ]
+                    .filter((messageId) => input.after === undefined || messageId > input.after)
+                    .sort()
+                    .slice(0, input.limit + 1),
+                  (messageId) =>
+                    decode(
+                      current.records.get(
+                        messageDeliveryKeyString({ ownerThreadId: input.ownerThreadId, messageId }),
+                      ) ?? "",
+                    ),
+                )
+              : yield* all();
+
+          const records = retained
+            .filter(
+              (record) =>
+                record.key.ownerThreadId === input.ownerThreadId &&
+                (input.after === undefined || record.key.messageId > input.after),
+            )
+            .sort((left, right) =>
+              left.key.messageId < right.key.messageId
+                ? -1
+                : left.key.messageId > right.key.messageId
+                  ? 1
+                  : 0,
+            );
+
+          const items = records.slice(0, input.limit);
+
+          return {
+            items,
+            next: records.length > input.limit ? (items.at(-1)?.key.messageId ?? null) : null,
+          };
+        }),
+        due: Effect.fn("MemoryMessageDeliveryStore.due")(
+          function* (nowMillis, limit, ownerThreadId) {
+            const input = yield* validateMessageDelivery(
+              Scan,
+              { nowMillis, limit, ...(ownerThreadId === undefined ? {} : { ownerThreadId }) },
+              "due",
+            );
+
+            return (yield* all())
+              .flatMap((record) => {
+                const deadline = messageDeliveryDeadline(record);
+
+                return deadline !== null &&
+                  deadline <= input.nowMillis &&
+                  (input.ownerThreadId === undefined ||
+                    input.ownerThreadId === record.key.ownerThreadId)
+                  ? [{ key: record.key, deadline }]
+                  : [];
+              })
+              .sort(
+                (left, right) =>
+                  left.deadline - right.deadline ||
+                  (messageDeliveryKeyString(left.key) < messageDeliveryKeyString(right.key)
+                    ? -1
+                    : 1),
+              )
+              .slice(0, input.limit)
+              .map((record) => record.key);
+          },
+        ),
+        nextDeadline: Effect.fn("MemoryMessageDeliveryStore.nextDeadline")(
+          function* (ownerThreadId) {
+            if (ownerThreadId !== undefined)
+              yield* validateMessageDelivery(ThreadId, ownerThreadId, "nextDeadline");
+            let next: number | null = null;
+
+            for (const record of yield* all()) {
+              if (ownerThreadId !== undefined && ownerThreadId !== record.key.ownerThreadId)
+                continue;
+              const deadline = messageDeliveryDeadline(record);
+
+              if (deadline !== null && (next === null || deadline < next)) next = deadline;
+            }
+
+            return next;
+          },
+        ),
+      });
+    }),
+  );
+
+export const MemoryMessageDeliveryStoreLive = memoryMessageDeliveryStoreLayer();