@yielded/agent-storage-memory 0.1.0-beta.166 → 0.1.0-beta.168

package/src/internal/MemoryThreadStoreKernel.ts

@@ -0,0 +1,156 @@
+import type { RunId, SubmissionId, ThreadId, ToolCallId } from "@yielded/agent/identifiers";
+import type { IdempotencyKey } from "@yielded/agent/receipt";
+import type { RecordEnvelope, RecordId } from "@yielded/agent/records";
+import type { StorageOwner } from "@yielded/agent/run-storage";
+import type { SubmissionSnapshot, WorkerLedgerState } from "@yielded/agent/submission-ledger";
+import type {
+  PreparedImportPage,
+  ThreadImportReader,
+  ThreadDeliveryImportReader,
+  ThreadImportRejected,
+} from "@yielded/agent/thread-import";
+import type {
+  AppendResult,
+  AppendRequest,
+  ThreadStoreFailure,
+  ThreadTail,
+  ThreadAdmission,
+  ThreadStoreError,
+  ThreadExportSnapshot,
+} from "@yielded/agent/thread-store";
+import type { TransferFacts, TransferSection } from "@yielded/agent/thread-transfer";
+import type {
+  ThreadWorkEntry,
+  WorkThreadsRequest,
+  WorkThreadsPage,
+} from "@yielded/agent/thread-work";
+import { Context, type Effect, type Stream } from "effect";
+
+export interface PreparedMemoryAppend {
+  readonly request: AppendRequest;
+  readonly batchJson: string;
+}
+
+/** Private storage, not a whole-Thread preparation value. Publication callbacks never yield. */
+export interface MemoryLedgerImport {
+  readonly reader: Pick<ThreadImportReader["Service"], "admission" | "runOwner" | "commands">;
+  readonly stage: (
+    page: PreparedImportPage,
+  ) => Effect.Effect<void, ThreadImportRejected | ThreadStoreError>;
+  readonly prepareCommit: (
+    workerSeal?: Pick<WorkerLedgerState, "terminal">,
+  ) => Effect.Effect<() => void, ThreadImportRejected | ThreadStoreError, ThreadImportReader>;
+}
+
+export interface MemoryLedgerTransfer {
+  readonly snapshot: (threadId: ThreadId) => Effect.Effect<
+    Omit<typeof ThreadExportSnapshot.Type, "deliveries"> & {
+      readonly idle: boolean;
+      readonly workerSeal?: Pick<WorkerLedgerState, "terminal">;
+    },
+    ThreadStoreError
+  >;
+  readonly facts: (
+    threadId: ThreadId,
+    section: Exclude<TransferSection, "deliveries">,
+    after: string | undefined,
+  ) => Effect.Effect<{ readonly facts: TransferFacts; readonly after: string }, ThreadStoreError>;
+  readonly startImport: (
+    threadId: ThreadId,
+  ) => Effect.Effect<MemoryLedgerImport, ThreadImportRejected | ThreadStoreError>;
+  readonly submissions: (threadId: ThreadId) => Stream.Stream<SubmissionSnapshot, ThreadStoreError>;
+  readonly admission: (
+    threadId: ThreadId,
+    submissionId: SubmissionId,
+  ) => Effect.Effect<ThreadAdmission | undefined, ThreadStoreError>;
+  readonly commands: ThreadImportReader["Service"]["commands"];
+}
+
+export interface MemoryDeliveryImport {
+  readonly record: ThreadImportReader["Service"]["delivery"];
+  readonly stage: (
+    page: PreparedImportPage,
+  ) => Effect.Effect<void, ThreadImportRejected | ThreadStoreError>;
+  readonly has: (messageId: IdempotencyKey) => boolean;
+  readonly prepareCommit: () => Effect.Effect<
+    () => void,
+    ThreadImportRejected | ThreadStoreError,
+    ThreadDeliveryImportReader
+  >;
+}
+
+export interface MemoryDeliveryTransfer {
+  readonly record: (
+    threadId: ThreadId,
+    messageId: IdempotencyKey,
+  ) => ReturnType<ThreadImportReader["Service"]["delivery"]>;
+  readonly snapshot: (threadId: ThreadId) => {
+    readonly idle: boolean;
+    readonly deliveries: number;
+  };
+  readonly facts: (
+    threadId: ThreadId,
+    after: string | undefined,
+  ) => Effect.Effect<{ readonly facts: TransferFacts; readonly after: string }, ThreadStoreError>;
+  readonly startImport: (
+    threadId: ThreadId,
+  ) => Effect.Effect<MemoryDeliveryImport, ThreadImportRejected | ThreadStoreError>;
+  readonly pendingPeerCount: (threadId: ThreadId, limit: number) => number;
+}
+
+/** Native control metadata only; callers already hold the journal's shared gate. */
+export interface MemoryWorkOwner {
+  readonly page: (
+    threadId: ThreadId,
+    after: string | undefined,
+    limit: number,
+  ) => Effect.Effect<
+    {
+      readonly entries: ReadonlyArray<ThreadWorkEntry>;
+      readonly after?: string;
+    },
+    ThreadStoreError
+  >;
+  readonly threads: (
+    request: WorkThreadsRequest,
+  ) => Effect.Effect<WorkThreadsPage, ThreadStoreError>;
+}
+
+/** One journal's private mutation boundary, shared with its paired ledger and delivery store. */
+export class MemoryThreadStoreKernel extends Context.Service<
+  MemoryThreadStoreKernel,
+  {
+    readonly owner: StorageOwner["Service"];
+    readonly withMutation: <A, E, R>(effect: Effect.Effect<A, E, R>) => Effect.Effect<A, E, R>;
+    readonly registerWorkOwner: (
+      kind: "admissions" | "deliveries",
+      owner: MemoryWorkOwner,
+    ) => Effect.Effect<void>;
+    readonly registerDeliveryLookup: (
+      exists: (threadId: ThreadId, messageId: IdempotencyKey) => boolean,
+    ) => Effect.Effect<void>;
+    /** Synchronous publication with the authoritative retained row, including replay membership. */
+    readonly checkThreadCapacity: (threadId: ThreadId) => Effect.Effect<void, ThreadStoreError>;
+    readonly initializeWork: (threadId: ThreadId) => void;
+    readonly retainDelivery: (threadId: ThreadId, messageId: IdempotencyKey) => void;
+    readonly registerLedgerTransfer: (transfer: MemoryLedgerTransfer) => Effect.Effect<void>;
+    readonly registerDeliveryTransfer: (transfer: MemoryDeliveryTransfer) => Effect.Effect<void>;
+    readonly prepareAppend: (
+      request: AppendRequest,
+    ) => Effect.Effect<PreparedMemoryAppend, ThreadStoreFailure>;
+    readonly appendPrepared: (
+      prepared: PreparedMemoryAppend,
+    ) => Effect.Effect<AppendResult, ThreadStoreFailure>;
+    readonly record: (
+      threadId: ThreadId,
+      recordId: RecordId,
+    ) => Effect.Effect<RecordEnvelope | undefined>;
+    /** Bounded canonical outcomes for one call; caller holds the shared mutation gate. */
+    readonly toolCallResults: (
+      threadId: ThreadId,
+      runId: RunId,
+      toolCallId: ToolCallId,
+    ) => Effect.Effect<ReadonlyArray<RecordEnvelope>>;
+    readonly tail: (threadId: ThreadId) => Effect.Effect<ThreadTail, ThreadStoreFailure>;
+  }
+>()("@effect-agent/storage-memory/internal/MemoryThreadStoreKernel") {}

package/src/internal/WorkSelection.ts

@@ -0,0 +1,29 @@
+/** Keep only the lowest distinct metadata keys after a cursor while scanning resident indexes. */
+export const boundedWorkSelection = <A>(
+  limit: number,
+  key: (value: A) => string,
+  after?: string,
+) => {
+  const values: Array<A> = [];
+
+  return {
+    values,
+    add: (value: A) => {
+      const candidate = key(value);
+
+      if (after !== undefined && candidate <= after) return;
+      let low = 0;
+      let high = values.length;
+
+      while (low < high) {
+        const middle = Math.floor((low + high) / 2);
+
+        if (key(values[middle]) < candidate) low = middle + 1;
+        else high = middle;
+      }
+      if (low >= limit || (low < values.length && key(values[low]) === candidate)) return;
+      if (values.length === limit) values.pop();
+      values.splice(low, 0, value);
+    },
+  };
+};