@columenlabs/lumen-ai 0.1.88 → 0.1.89

package/dist/assistant/engine.d.ts

@@ -160,6 +160,12 @@ export declare class Assistant {
     readonly state: State;
     private readonly groups;
     constructor(o: AssistantOptions);
+    /**
+     * This assistant for one request: its documents are read once each (`Docs.cached`), so a page of
+     * Settings or a chat turn costs a handful of store calls, not dozens. `assistantRoutes` makes one
+     * per request itself.
+     */
+    forRequest(): Assistant;
     private anthropic;
     private openai;
     private clients;

package/dist/assistant/engine.js

@@ -172,6 +172,16 @@ export class Assistant {
                 : {}),
         });
     }
+    /**
+     * This assistant for one request: its documents are read once each (`Docs.cached`), so a page of
+     * Settings or a chat turn costs a handful of store calls, not dozens. `assistantRoutes` makes one
+     * per request itself.
+     */
+    forRequest() {
+        const view = Object.create(this);
+        Object.defineProperty(view, 'state', { value: this.state.withDocs(this.state.docs.cached()) });
+        return view;
+    }
     anthropic(apiKey) {
         const f = this.o.fetch;
         return new Anthropic({ apiKey, maxRetries: 1, ...(f ? { fetch: f } : {}) });

package/dist/assistant/routes.d.ts

@@ -6,5 +6,5 @@ export interface AssistantRoutesOptions {
     /** The verified caller, or null (403). The app decides who is an admin. */
     caller: (req: Request) => Awaitable<Caller | null>;
 }
-export declare function assistantRoutes(a: Assistant, o: AssistantRoutesOptions): (req: Request) => Promise<Response>;
+export declare function assistantRoutes(app: Assistant, o: AssistantRoutesOptions): (req: Request) => Promise<Response>;
 export {};

package/dist/assistant/routes.js

@@ -121,10 +121,12 @@ function settingsChange(a, groups, b) {
         };
     };
 }
-export function assistantRoutes(a, o) {
+export function assistantRoutes(app, o) {
     const base = o.base.replace(/\/+$/, '');
-    const docs = a.state.docs;
     return async (req) => {
+        // One request's view: each stored document is read once however many routes ask for it.
+        const a = app.forRequest();
+        const docs = a.state.docs;
         const url = new URL(req.url);
         if (!url.pathname.startsWith(base))
             return fail('Not found.', 404);

package/dist/assistant/state.d.ts

@@ -127,6 +127,8 @@ export declare class State {
         fetch?: typeof fetch;
         allowance?: AllowanceConfig;
     });
+    /** The same state over other documents (a request's `Docs.cached`). */
+    withDocs(docs: Docs): State;
     get allowanceConfig(): AllowanceConfig | undefined;
     allowance(id: string): Promise<AllowanceDoc>;
     setAllowance(id: string, change: (d: AllowanceDoc) => AllowanceDoc): Promise<AllowanceDoc | null>;

package/dist/assistant/state.js

@@ -32,6 +32,10 @@ export class State {
         this.docs = docs;
         this.o = o;
     }
+    /** The same state over other documents (a request's `Docs.cached`). */
+    withDocs(docs) {
+        return new State(docs, this.o);
+    }
     get allowanceConfig() {
         return this.o.allowance;
     }

package/dist/assistant/store.d.ts

@@ -61,12 +61,26 @@ export declare function sqlAssistantStore(sql: SqlRunner): AssistantStore;
 export declare class Docs {
     private readonly store;
     private readonly sealer?;
-    constructor(store: AssistantStore, sealer?: Sealer | undefined);
+    /** Opened values already read in this request (`cached`), by scope and key. */
+    private readonly memo?;
+    constructor(store: AssistantStore, sealer?: Sealer | undefined, 
+    /** Opened values already read in this request (`cached`), by scope and key. */
+    memo?: Map<string, Promise<string | null>> | undefined);
+    /**
+     * The same documents with each one read once: one request (a Settings page, a chat turn) reads
+     * a person's settings, keys and spend many times, and each read is a store call and an unseal.
+     * Writes keep it current; `update` always reads the store, so a change never builds on a value
+     * another request has since replaced. Make one per request, never one per app.
+     */
+    cached(): Docs;
     private seal;
     private open;
+    private id;
+    private fresh;
     read<T>(scope: string, key: string): Promise<T | null>;
     write<T>(scope: string, key: string, value: T, meta?: string): Promise<void>;
-    /** Read, change and write back; `change` returning null removes it. */
+    /** Read (from the store, never the request's copy), change and write back; `change` returning
+     * null removes it. */
     update<T>(scope: string, key: string, change: (prev: T | null) => T | null): Promise<T | null>;
     remove(scope: string, key: string): Promise<void>;
     list(scope: string, prefix: string, limit: number): Promise<{

package/dist/assistant/store.js

@@ -84,30 +84,66 @@ export function sqlAssistantStore(sql) {
 export class Docs {
     store;
     sealer;
-    constructor(store, sealer) {
+    memo;
+    constructor(store, sealer, 
+    /** Opened values already read in this request (`cached`), by scope and key. */
+    memo) {
         this.store = store;
         this.sealer = sealer;
+        this.memo = memo;
+    }
+    /**
+     * The same documents with each one read once: one request (a Settings page, a chat turn) reads
+     * a person's settings, keys and spend many times, and each read is a store call and an unseal.
+     * Writes keep it current; `update` always reads the store, so a change never builds on a value
+     * another request has since replaced. Make one per request, never one per app.
+     */
+    cached() {
+        return new Docs(this.store, this.sealer, new Map());
     }
     seal = (s) => (this.sealer ? this.sealer.seal(s) : Promise.resolve(s));
     open = (s) => (this.sealer ? this.sealer.open(s) : Promise.resolve(s));
-    async read(scope, key) {
+    id = (scope, key) => `${scope}\u0000${key}`;
+    async fresh(scope, key) {
         const d = await this.store.get(scope, key);
-        return d ? JSON.parse(await this.open(d.value)) : null;
+        return 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);
+            if (!hit) {
+                this.memo.set(id, text);
+                text.catch(() => this.memo?.delete(id));
+            }
+        }
+        else
+            text = this.fresh(scope, key);
+        const t = await text;
+        // Parsed each time, so a caller that changes what it got never changes the next read.
+        return t === null ? null : JSON.parse(t);
     }
     async write(scope, key, value, meta) {
-        await this.store.put(scope, key, await this.seal(JSON.stringify(value)), meta === undefined ? null : await this.seal(meta));
+        const text = JSON.stringify(value);
+        await this.store.put(scope, key, await this.seal(text), meta === undefined ? null : await this.seal(meta));
+        this.memo?.set(this.id(scope, key), Promise.resolve(text));
     }
-    /** Read, change and write back; `change` returning null removes it. */
+    /** Read (from the store, never the request's copy), change and write back; `change` returning
+     * null removes it. */
     async update(scope, key, change) {
-        const next = change(await this.read(scope, key));
+        const t = await this.fresh(scope, key);
+        const next = change(t === null ? null : JSON.parse(t));
         if (next === null)
-            await this.store.remove(scope, key);
+            await this.remove(scope, key);
         else
             await this.write(scope, key, next);
         return next;
     }
-    remove(scope, key) {
-        return this.store.remove(scope, key);
+    async remove(scope, key) {
+        await this.store.remove(scope, key);
+        this.memo?.set(this.id(scope, key), Promise.resolve(null));
     }
     async list(scope, prefix, limit) {
         const rows = await this.store.list(scope, prefix, limit);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@columenlabs/lumen-ai",
-  "version": "0.1.88",
+  "version": "0.1.89",
   "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.88",
-    "@columenlabs/lumen-ui-types": "0.1.88",
+    "@columenlabs/lumen-ops": "0.1.89",
+    "@columenlabs/lumen-ui-types": "0.1.89",
     "openai": "7.32.0",
     "zod": "^4.3.6"
   },