@columenlabs/lumen-ai 0.1.93 → 0.1.94

package/dist/assistant/store.d.ts

@@ -25,6 +25,13 @@ export interface AssistantStore {
     /** Creates the table. Safe to call often. */
     init(): Promise<void>;
     get(scope: string, key: string): Promise<StoredDoc | null>;
+    /** Several documents in one call, in the order asked (null where missing). Optional: a store
+     * across a network hop (a Durable Object stub) gives it so a request's reads in one tick are one
+     * call; `Docs.cached` uses it when present and `get` otherwise. */
+    getMany?(refs: {
+        scope: string;
+        key: string;
+    }[]): Promise<(StoredDoc | null)[]>;
     put(scope: string, key: string, value: string, meta?: string | null): Promise<void>;
     remove(scope: string, key: string): Promise<void>;
     /** Keys starting with `prefix`, newest first, without their values. */
@@ -77,6 +84,10 @@ export declare class Docs {
     private open;
     private id;
     private fresh;
+    /** Reads asked in the same tick, waiting to go as one `getMany` call. */
+    private batch;
+    /** One stored doc, joined with the other reads of this tick when the store can batch them. */
+    private batched;
     read<T>(scope: string, key: string): Promise<T | null>;
     write<T>(scope: string, key: string, value: T, meta?: string): Promise<void>;
     /** Read (from the store, never the request's copy), change and write back; `change` returning

package/dist/assistant/store.js

@@ -55,6 +55,24 @@ export function sqlAssistantStore(sql) {
                 }
                 : null;
         },
+        async getMany(refs) {
+            await init();
+            if (!refs.length)
+                return [];
+            const rows = await sql.all(`SELECT scope, key, meta, value, at FROM ${TABLE} WHERE ${refs.map(() => '(scope = ? AND key = ?)').join(' OR ')}`, ...refs.flatMap((r) => [r.scope, r.key]));
+            const by = new Map(rows.map((r) => [`${r.scope}\u0000${r.key}`, r]));
+            return refs.map(({ scope, key }) => {
+                const r = by.get(`${scope}\u0000${key}`);
+                return r
+                    ? {
+                        key: String(r.key),
+                        meta: r.meta == null ? null : String(r.meta),
+                        value: String(r.value),
+                        at: Number(r.at),
+                    }
+                    : null;
+            });
+        },
         async put(scope, key, value, meta = null) {
             await init();
             await sql.run(`INSERT INTO ${TABLE} (scope, key, meta, value, at) VALUES (?, ?, ?, ?, ?) ON CONFLICT (scope, key) DO UPDATE SET meta = excluded.meta, value = excluded.value, at = excluded.at`, scope, key, meta, value, Date.now());
@@ -108,12 +126,33 @@ export class Docs {
         const d = await this.store.get(scope, key);
         return d ? this.open(d.value) : null;
     }
+    /** Reads asked in the same tick, waiting to go as one `getMany` call. */
+    batch = null;
+    /** One stored doc, joined with the other reads of this tick when the store can batch them. */
+    batched(scope, key) {
+        const many = this.store.getMany?.bind(this.store);
+        if (!many)
+            return this.fresh(scope, key);
+        const doc = new Promise((resolve, reject) => {
+            if (!this.batch) {
+                const queue = [];
+                this.batch = queue;
+                queueMicrotask(() => {
+                    this.batch = null;
+                    const all = Promise.resolve().then(() => many(queue.map(({ scope, key }) => ({ scope, key }))));
+                    queue.forEach((q, i) => q.done(all.then((docs) => docs[i] ?? null)));
+                });
+            }
+            this.batch.push({ scope, key, done: (d) => d.then(resolve, reject) });
+        });
+        return doc.then((d) => (d ? this.open(d.value) : null));
+    }
     async read(scope, key) {
         let text;
         if (this.memo) {
             const id = this.id(scope, key);
             const hit = this.memo.get(id);
-            text = hit ?? this.fresh(scope, key);
+            text = hit ?? this.batched(scope, key);
             if (!hit) {
                 this.memo.set(id, text);
                 text.catch(() => this.memo?.delete(id));

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@columenlabs/lumen-ai",
-  "version": "0.1.93",
+  "version": "0.1.94",
   "description": "Lumen's assistant and agent parts: a chat assistant's server (Claude tiers, tools over MCP, the web, hand off, spend caps), serving an MCP server from a Worker, read-only tool sets and metered tool calls.",
   "license": "MIT",
   "type": "module",
@@ -41,8 +41,8 @@
   },
   "dependencies": {
     "@anthropic-ai/sdk": "0.133.0",
-    "@columenlabs/lumen-ops": "0.1.93",
-    "@columenlabs/lumen-ui-types": "0.1.93",
+    "@columenlabs/lumen-ops": "0.1.94",
+    "@columenlabs/lumen-ui-types": "0.1.94",
     "openai": "7.32.0",
     "zod": "^4.3.6"
   },