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

package/src/semantic-memory-index.ts

@@ -50,9 +50,12 @@ interface IndexData {
 
 const sameProfile = Schema.toEquivalence(SemanticMemoryProfile);
 const sameSource = Schema.toEquivalence(MemoryIndexSource.Wire);
+
 const error = (operation: string, reason: MemoryIndexError["reason"]): MemoryIndexError =>
   MemoryIndexError.make({ operation, reason });
+
 const keyString = (key: MemoryKey): string => JSON.stringify([key.namespace.address, key.id]);
+
 const sourceIdentityBytes = (source: MemoryIndexSource): number =>
   Encoding.encodeHex(JSON.stringify(source)).length / 2;
 
@@ -91,10 +94,12 @@ const sourceIsFenced = (source: MemoryIndexSource, existing: StoredEntry): boole
 
 const squaredNorm = (vector: ReadonlyArray<number>): number | null => {
   let sum = 0;
+
   for (const value of vector) {
     sum += value * value;
     if (!Number.isFinite(sum)) return null;
   }
+
   return sum > 0 ? sum : null;
 };
 
@@ -108,9 +113,11 @@ const validateChunks = Effect.fn("InMemorySemanticIndex.validateChunks")(functio
 ): Effect.fn.Return<void, MemoryIndexError> {
   let nextByte = 0;
   const passageIds = new Set<string>();
+
   for (let index = 0; index < chunks.length; index++) {
     const chunk = chunks[index];
     const byteLength = Encoding.encodeHex(chunk.text).length / 2;
+
     if (
       chunk.ordinal !== index ||
       chunk.startByte !== nextByte ||
@@ -131,10 +138,12 @@ const cosine = (left: ReadonlyArray<number>, right: ReadonlyArray<number>): numb
   const leftNorm = Math.sqrt(squaredNorm(left) ?? 1);
   const rightNorm = Math.sqrt(squaredNorm(right) ?? 1);
   let score = 0;
+
   for (let index = 0; index < left.length; index++) {
     score += (left[index] / leftNorm) * (right[index] / rightNorm);
   }
   const bounded = Math.max(-1, Math.min(1, score));
+
   return bounded === 0 ? 0 : bounded;
 };
 
@@ -154,16 +163,19 @@ const makeIndex = Effect.fn("InMemorySemanticIndex.make")(function* (
       )),
     }),
   );
+
   const capacity = yield* decodeBoundary(
     InMemorySemanticIndexCapacity,
     rawCapacity,
     "configure semantic memory index",
   );
+
   if (capacity.maxChunks * profile.dimensions > MaxStoredVectorComponents) {
     return yield* error("configure semantic memory index", "invalid-input");
   }
   const maxSourceBytes = capacity.maxSourceBytes ?? 16_777_216;
   const data = yield* Ref.make<IndexData>({ closed: false, entries: new Map(), sourceBytes: 0 });
+
   yield* Effect.addFinalizer(() =>
     Ref.set(data, { closed: true, entries: new Map(), sourceBytes: 0 }),
   );
@@ -176,21 +188,25 @@ const makeIndex = Effect.fn("InMemorySemanticIndex.make")(function* (
     "InMemorySemanticIndex.replace",
   )(function* (rawRequest) {
     const operation = "replace semantic memory source";
+
     yield* ensureOpen(operation);
     const request = yield* decodeBoundary(MemoryIndexReplacement.Wire, rawRequest, operation);
     const source = freezeSource(request.source);
     const sourceBytes = sourceIdentityBytes(source);
     const chunks = Object.freeze(request.chunks.map(freezeChunk));
+
     if (source.source.id !== source.key.id) return yield* error(operation, "invalid-input");
     if (!sameProfile(request.profile, profile)) return yield* error(operation, "incompatible");
     yield* validateChunks(chunks, profile, operation);
     const indexedAt = yield* Clock.currentTimeMillis;
+
     const failure = yield* Ref.modify(
       data,
       (current): readonly [MemoryIndexError | undefined, IndexData] => {
         if (current.closed) return [error(operation, "unavailable"), current];
         const id = keyString(source.key);
         const existing = current.entries.get(id);
+
         if (
           existing !== undefined &&
           (existing._tag === "Withdrawn" || sourceIsFenced(source, existing))
@@ -201,17 +217,22 @@ const makeIndex = Effect.fn("InMemorySemanticIndex.make")(function* (
           return [error(operation, "budget"), current];
         }
         const nextSourceBytes = current.sourceBytes - (existing?.sourceBytes ?? 0) + sourceBytes;
+
         if (nextSourceBytes > maxSourceBytes) return [error(operation, "budget"), current];
         let count = chunks.length;
+
         for (const [entryId, entry] of current.entries) {
           if (entryId !== id && entry._tag === "Indexed") count += entry.chunks.length;
         }
         if (count > capacity.maxChunks) return [error(operation, "budget"), current];
         const entries = new Map(current.entries);
+
         entries.set(id, { _tag: "Indexed", source, sourceBytes, chunks, indexedAt });
+
         return [undefined, { ...current, entries, sourceBytes: nextSourceBytes }];
       },
     );
+
     if (failure !== undefined) return yield* failure;
   });
 
@@ -219,18 +240,24 @@ const makeIndex = Effect.fn("InMemorySemanticIndex.make")(function* (
     "InMemorySemanticIndex.withdraw",
   )(function* (rawSource) {
     const operation = "withdraw semantic memory source";
+
     yield* ensureOpen(operation);
+
     const source = freezeSource(
       yield* decodeBoundary(MemoryIndexSource.Wire, rawSource, operation),
     );
+
     const sourceBytes = sourceIdentityBytes(source);
+
     if (source.source.id !== source.key.id) return yield* error(operation, "invalid-input");
+
     const failure = yield* Ref.modify(
       data,
       (current): readonly [MemoryIndexError | undefined, IndexData] => {
         if (current.closed) return [error(operation, "unavailable"), current];
         const id = keyString(source.key);
         const existing = current.entries.get(id);
+
         if (existing !== undefined) {
           if (existing._tag === "Withdrawn") {
             return [
@@ -243,26 +270,34 @@ const makeIndex = Effect.fn("InMemorySemanticIndex.make")(function* (
           return [error(operation, "budget"), current];
         }
         const nextSourceBytes = current.sourceBytes - (existing?.sourceBytes ?? 0) + sourceBytes;
+
         if (nextSourceBytes > maxSourceBytes) return [error(operation, "budget"), current];
         const entries = new Map(current.entries);
+
         entries.set(id, { _tag: "Withdrawn", source, sourceBytes });
+
         return [undefined, { ...current, entries, sourceBytes: nextSourceBytes }];
       },
     );
+
     if (failure !== undefined) return yield* failure;
   });
 
   const search = Effect.fn("InMemorySemanticIndex.search")(function* (rawQuery: MemoryIndexQuery) {
     const operation = "search semantic memory index";
+
     yield* ensureOpen(operation);
     const query = yield* decodeBoundary(MemoryIndexQuery.Wire, rawQuery, operation);
     const vector = Object.freeze([...query.vector]);
+
     if (!validVector(vector, profile)) return yield* error(operation, "invalid-input");
     const current = yield* Ref.get(data);
+
     if (current.closed) return yield* error(operation, "unavailable");
     let scannedChunks = 0;
     let inspectedSources = 0;
     const candidates: Array<MemoryIndexCandidate> = [];
+
     for (const entry of current.entries.values()) {
       inspectedSources += 1;
       if (inspectedSources % 128 === 0) yield* Effect.yieldNow;
@@ -283,6 +318,7 @@ const makeIndex = Effect.fn("InMemorySemanticIndex.make")(function* (
       yield* Effect.yieldNow;
       for (const chunk of entry.chunks) {
         const score = cosine(vector, chunk.vector);
+
         if (score < query.minScore) continue;
         candidates.push(
           MemoryIndexCandidate.make({
@@ -306,6 +342,7 @@ const makeIndex = Effect.fn("InMemorySemanticIndex.make")(function* (
         left.ordinal - right.ordinal,
     );
     yield* ensureOpen(operation);
+
     return MemoryIndexSearch.make({ candidates: candidates.slice(0, query.limit), scannedChunks });
   });
 

package/src/testing.ts

@@ -9,6 +9,7 @@ export {
   type SubmissionLedgerConformanceCase,
   type SubmissionLedgerConformanceFailure,
 } from "@effect-agent/thread/testing";
+
 export {
   scheduleStoreConformanceCases,
   ScheduleStoreConformanceViolation,