@cursor/july 0.1.4 → 0.1.6

package/dist/internal/storage-coordinator.js

@@ -10,9 +10,9 @@
  * failures — a throwing sink is logged and its write dropped; storage
  * must never stall or fail a turn.
  *
- * Scaling shape: sessions, reminders, evals, and A/Bs all reduce to keyed
- * puts on the same queue, so one author-owned sink covers every domain,
- * and new domains are new key prefixes — not new config surface.
+ * Scaling shape: sessions and reminders reduce to keyed puts on the KV
+ * sink; eval runs and A/B metrics go to their dedicated tables
+ * (`evals` / `abs`). Everything shares one bounded, serialized queue.
  */
 var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
     function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
@@ -139,18 +139,10 @@ export class StorageCoordinator {
         const ops = [];
         const first = buffer.events[0];
         if (first !== undefined) {
-            ops.push({
-                op: "put",
-                key: storageKeys.sessionEvents(this.agentName, sessionId, first.index),
-                value: buffer.events,
-            });
+            ops.push(this.putOp(storageKeys.sessionEvents(this.agentName, sessionId, first.index), buffer.events));
         }
         if (buffer.record !== undefined) {
-            ops.push({
-                op: "put",
-                key: storageKeys.session(this.agentName, sessionId),
-                value: buffer.record,
-            });
+            ops.push(this.putOp(storageKeys.session(this.agentName, sessionId), buffer.record));
             ops.push(...this.continuationOps(buffer.record));
         }
         if (ops.length > 0) {
@@ -170,20 +162,27 @@ export class StorageCoordinator {
         this.continuationIndex.set(record.sessionId, next);
         const ops = [];
         if (previous != null) {
-            ops.push({
-                op: "delete",
-                key: storageKeys.continuation(this.agentName, record.channelId, previous),
-            });
+            ops.push(this.deleteOp(storageKeys.continuation(this.agentName, record.channelId, previous)));
         }
         if (next != null) {
-            ops.push({
-                op: "put",
-                key: storageKeys.continuation(this.agentName, record.channelId, next),
-                value: { sessionId: record.sessionId },
-            });
+            ops.push(this.putOp(storageKeys.continuation(this.agentName, record.channelId, next), { sessionId: record.sessionId }));
         }
         return ops;
     }
+    /** KV upsert op on the sink's `put`. */
+    putOp(key, value) {
+        return {
+            label: `put(${key})`,
+            run: (ctx) => this.definition.put(key, value, ctx),
+        };
+    }
+    /** KV delete op on the sink's `delete` (skipped when the hook is absent). */
+    deleteOp(key) {
+        return {
+            label: `delete(${key})`,
+            run: (ctx) => { var _a, _b; return (_b = (_a = this.definition).delete) === null || _b === void 0 ? void 0 : _b.call(_a, key, ctx); },
+        };
+    }
     // ==========================================================================
     // Sessions (reads / restore)
     // ==========================================================================
@@ -279,11 +278,7 @@ export class StorageCoordinator {
             return;
         }
         this.enqueue([
-            {
-                op: "put",
-                key: storageKeys.reminder(this.agentName, record.id),
-                value: record,
-            },
+            this.putOp(storageKeys.reminder(this.agentName, record.id), record),
         ], "policy");
     }
     /**
@@ -297,93 +292,97 @@ export class StorageCoordinator {
         });
     }
     // ==========================================================================
-    // Evals
+    // Evals (dedicated `evals` table)
     // ==========================================================================
     /**
-     * Adapter for {@link EvalRunPersistence} so the playground eval store
-     * can fall back to this sink when `evals.config.ts` sets no
-     * `persistRuns`.
+     * Adapter over the sink's dedicated `evals` table for the playground
+     * eval-run store. Undefined when the table is not configured — eval
+     * history then stays in process memory.
      */
-    asEvalRunPersistence() {
+    evalRuns() {
+        const table = this.definition.evals;
+        if (table === undefined) {
+            return undefined;
+        }
         return {
-            load: () => __awaiter(this, void 0, void 0, function* () {
-                const entries = yield this.tryList(storageKeys.evalRunPrefix(this.agentName));
-                return entries
-                    .map((entry) => entry.value)
-                    .filter((run) => run != null);
-            }),
             save: (run) => {
+                // Clone at enqueue time: the store mutates snapshots in place as
+                // cases finish, and delivery is async.
+                const snapshot = structuredClone(run);
                 this.enqueue([
                     {
-                        op: "put",
-                        key: storageKeys.evalRun(this.agentName, run.runId),
-                        value: run,
+                        label: `evals.put(${run.runId})`,
+                        run: (ctx) => table.put(snapshot, ctx),
                     },
                 ], "policy");
             },
             delete: (runId) => {
                 this.enqueue([
                     {
-                        op: "delete",
-                        key: storageKeys.evalRun(this.agentName, runId),
+                        label: `evals.delete(${runId})`,
+                        run: (ctx) => table.delete(runId, ctx),
                     },
                 ], "policy");
             },
+            list: () => __awaiter(this, void 0, void 0, function* () {
+                try {
+                    const runs = yield table.list(this.context("restore"));
+                    return Array.isArray(runs) ? runs : [];
+                }
+                catch (error) {
+                    this.logger(`[agentkit] storage evals.list() failed: ${describeError(error)}`);
+                    return [];
+                }
+            }),
         };
     }
     // ==========================================================================
-    // A/Bs
+    // A/Bs (dedicated `abs` table)
     // ==========================================================================
-    /**
-     * Adapter for {@link ABSamplePersistence} so the AB collector can fall
-     * back to this sink when `ab.config.ts` sets no `persistSamples`.
-     */
-    asABSamplePersistence() {
-        return {
-            save: (sample) => {
-                this.enqueue([
-                    {
-                        op: "put",
-                        key: storageKeys.abSample(this.agentName, sample.sessionId, sample.at),
-                        value: sample,
-                    },
-                ], "policy");
+    /** Append one metric sample to the `abs` table (no-op without it). */
+    abSample(sample) {
+        const table = this.definition.abs;
+        if (this.closed || table === undefined) {
+            return;
+        }
+        this.enqueue([
+            {
+                label: `abs.putSample(${sample.sessionId})`,
+                run: (ctx) => table.putSample(sample, ctx),
             },
-        };
+        ], "policy");
     }
     /**
      * Refresh the persisted aggregate A/B snapshot, throttled to once per
      * {@link AB_SNAPSHOT_MIN_INTERVAL_MS} (the playground recomputes the
-     * fold on every `GET /v1/abs` poll).
+     * fold on every `GET /v1/abs` poll). No-op without `abs.putSnapshot`.
      */
     abSnapshot(snapshot) {
+        var _a;
+        const putSnapshot = (_a = this.definition.abs) === null || _a === void 0 ? void 0 : _a.putSnapshot;
         const now = Date.now();
         if (this.closed ||
+            putSnapshot === undefined ||
             now - this.lastAbSnapshotAt < AB_SNAPSHOT_MIN_INTERVAL_MS) {
             return;
         }
         this.lastAbSnapshotAt = now;
-        this.enqueue([
-            {
-                op: "put",
-                key: storageKeys.abSnapshot(this.agentName),
-                value: snapshot,
-            },
-        ], "policy");
+        this.enqueue([{ label: "abs.putSnapshot", run: (ctx) => putSnapshot(snapshot, ctx) }], "policy");
     }
     /** Latest persisted aggregate A/B snapshot; errors read as absent. */
     getLatestAbSnapshot() {
         return __awaiter(this, void 0, void 0, function* () {
-            const get = this.definition.get;
-            if (get === undefined) {
+            var _a;
+            const getSnapshot = (_a = this.definition.abs) === null || _a === void 0 ? void 0 : _a.getSnapshot;
+            if (getSnapshot === undefined) {
                 return undefined;
             }
             try {
-                const value = yield get(storageKeys.abSnapshot(this.agentName), this.context("restore"));
-                return value == null ? undefined : value;
+                const value = yield getSnapshot(this.context("restore"));
+                return value !== null && value !== void 0 ? value : undefined;
             }
             catch (error) {
-                this.logger(`[agentkit] storage get(ab-snapshot) failed: ${describeError(error)}`);
+                this.logger(`[agentkit] storage abs.getSnapshot() failed: ${describeError(error)}`);
                 return undefined;
             }
         });
@@ -474,18 +473,12 @@ export class StorageCoordinator {
         this.pending += ops.length;
         const ctx = this.context(reason);
         this.queue = this.queue.then(() => __awaiter(this, void 0, void 0, function* () {
-            var _a, _b;
             for (const op of ops) {
                 try {
-                    if (op.op === "put") {
-                        yield this.definition.put(op.key, op.value, ctx);
-                    }
-                    else {
-                        yield (_b = (_a = this.definition).delete) === null || _b === void 0 ? void 0 : _b.call(_a, op.key, ctx);
-                    }
+                    yield op.run(ctx);
                 }
                 catch (error) {
-                    this.logger(`[agentkit] storage ${op.op}(${op.key}) failed: ${describeError(error)}`);
+                    this.logger(`[agentkit] storage ${op.label} failed: ${describeError(error)}`);
                 }
                 finally {
                     this.pending -= 1;