@columenlabs/lumen-ai 0.1.92 → 0.1.94

package/dist/assistant/engine.d.ts

@@ -1,4 +1,4 @@
-import type { AllowanceRequest, AllowanceState, AllowanceUnit, AssistantAccess, AssistantChat, AssistantChatRow, AssistantMessage, AssistantProvider, AssistantStatus, DraftItem, StepItem } from '@columenlabs/lumen-ui-types/assistant';
+import type { AllowanceRequest, AllowanceState, AllowanceUnit, AssistantAccess, AssistantChat, AssistantChatRow, AssistantMessage, AssistantOwnWay, AssistantProvider, AssistantStatus, DraftItem, StepItem } from '@columenlabs/lumen-ui-types/assistant';
 import { type ModelDef, type TaskDef, type TierDef } from './models.js';
 import { State } from './state.js';
 import { type AssistantStore, type Sealer } from './store.js';
@@ -234,10 +234,18 @@ export declare class Assistant {
         url: string;
         redirect: string;
     }>;
-    /** Finishes it from the address it ended on; the plan then stands in for the person's own key. */
+    /**
+     * Finishes it from the address it ended on. The plan is kept beside the person's key; a person who
+     * already has a key keeps running on it until they pick the plan.
+     */
     finishSignin(caller: Caller, provider: AssistantProvider, pasted: string): Promise<void>;
-    /** Tests a person's own key, refreshing a plan sign-in first. */
-    testOwn(caller: Caller, provider: AssistantProvider): Promise<import("./state.js").KeyTest | null>;
+    /** Signs the person out of their plan; their key, if any, runs from then on. */
+    signOut(caller: Caller, provider: AssistantProvider): Promise<void>;
+    /**
+     * Tests one of the person's own (`way`, else the one in use), refreshing a plan first, and keeps
+     * the result on it.
+     */
+    testOwn(caller: Caller, provider: AssistantProvider, way?: AssistantOwnWay): Promise<import("./state.js").KeyTest | null>;
     /** One free call (reading a model) that says whether the provider takes the key. */
     testKey(provider: AssistantProvider, apiKey: string): Promise<{
         ok: boolean;

package/dist/assistant/engine.js

@@ -21,7 +21,7 @@ import { HAND_OFF_WHYS } from '@columenlabs/lumen-ui-types/assistant';
 import OpenAI from 'openai';
 import { CHATGPT_REDIRECT, SigninError, finishChatgpt, startChatgpt, testChatgpt, } from './chatgpt.js';
 import { ALL_MODELS, DEFAULT_OUT, Meter, PROVIDERS, effortParams, } from './models.js';
-import { DEFAULT_CAP, State, keyDocName, keyState, waitText, } from './state.js';
+import { DEFAULT_CAP, State, keyDocName, keyState, planDocName, waitText, } from './state.js';
 import { Docs } from './store.js';
 import { ToolError, rowCount, toolName, withDeadline, } from './tools.js';
 import { scrapeqlTools, webFetchTools } from './web.js';
@@ -248,10 +248,12 @@ export class Assistant {
         const [p, providers, scrapeql, spend, appCap, ownCap, { paying, wait }] = await Promise.all([
             this.state.person(caller.id),
             Promise.all(this.providers.map(async (id) => {
-                const [doc, key, own] = await Promise.all([
+                const [doc, key, own, plan, use] = await Promise.all([
                     this.state.appKey(id),
                     this.state.appApiKey(id),
                     this.state.ownKey(caller.id, id),
+                    PROVIDERS[id].signin ? this.state.ownPlan(caller.id, id) : Promise.resolve(null),
+                    this.state.ownUse(caller.id, id),
                 ]);
                 const app = caller.admin
                     ? keyState(doc, (d) => d.api_key)
@@ -264,6 +266,10 @@ export class Assistant {
                     ...(PROVIDERS[id].signin ? { signin: PROVIDERS[id].signin } : {}),
                     app: { ...app, ...(key?.fromEnv ? { from_env: true } : {}) },
                     own: keyState(own, (d) => d.api_key),
+                    ...(PROVIDERS[id].signin
+                        ? { plan: keyState(plan?.doc ?? null, (d) => d.api_key) }
+                        : {}),
+                    ...(use ? { use } : {}),
                 };
             })),
             this.o.web?.scrapeql ? this.state.scrapeql() : Promise.resolve(null),
@@ -1421,19 +1427,27 @@ export class Assistant {
         await this.state.docs.write(caller.id, name, reg);
         return { url, redirect: CHATGPT_REDIRECT };
     }
-    /** Finishes it from the address it ended on; the plan then stands in for the person's own key. */
+    /**
+     * Finishes it from the address it ended on. The plan is kept beside the person's key; a person who
+     * already has a key keeps running on it until they pick the plan.
+     */
     async finishSignin(caller, provider, pasted) {
         const name = `signin:${provider}`;
         try {
             const { tokens, reg } = await finishChatgpt(await this.state.docs.read(caller.id, name), pasted, this.o.fetch ?? fetch);
             await this.state.docs.write(caller.id, name, reg);
             const test = await testChatgpt(tokens, this.o.fetch ?? fetch);
-            await this.state.docs.write(caller.id, keyDocName(provider), {
+            const legacy = await this.state.ownPlan(caller.id, provider);
+            await this.state.docs.write(caller.id, planDocName(provider), {
                 api_key: tokens.access_token,
                 saved_at: Date.now(),
                 test,
                 chatgpt: tokens,
             });
+            if (legacy && legacy.name !== planDocName(provider))
+                await this.state.docs.remove(caller.id, legacy.name);
+            if (await this.state.ownKey(caller.id, provider))
+                await this.state.setPerson(caller.id, (d) => d.own_use?.[provider] ? d : { ...d, own_use: { ...d.own_use, [provider]: 'key' } });
         }
         catch (err) {
             if (err instanceof SigninError)
@@ -1441,18 +1455,35 @@ export class Assistant {
             throw err;
         }
     }
-    /** Tests a person's own key, refreshing a plan sign-in first. */
-    async testOwn(caller, provider) {
-        const d = await this.state.ownKey(caller.id, provider);
-        if (!d)
+    /** Signs the person out of their plan; their key, if any, runs from then on. */
+    async signOut(caller, provider) {
+        const found = await this.state.ownPlan(caller.id, provider);
+        if (found)
+            await this.state.docs.remove(caller.id, found.name);
+    }
+    /**
+     * Tests one of the person's own (`way`, else the one in use), refreshing a plan first, and keeps
+     * the result on it.
+     */
+    async testOwn(caller, provider, way) {
+        const w = way ?? (await this.state.ownUse(caller.id, provider));
+        if (w === 'key') {
+            const d = await this.state.ownKey(caller.id, provider);
+            if (!d)
+                return null;
+            const test = await this.testKey(provider, d.api_key);
+            await this.state.docs.write(caller.id, keyDocName(provider), { ...d, test });
+            return test;
+        }
+        if (w !== 'plan' || !(await this.state.ownPlan(caller.id, provider)))
             return null;
-        if (!d.chatgpt)
-            return this.testKey(provider, d.api_key);
-        const fresh = await this.state.ownApiKey(caller.id, provider);
-        const now = await this.state.ownKey(caller.id, provider);
-        if (!fresh || !now?.chatgpt)
-            return now?.test ?? { ok: false, detail: 'Sign in again.', at: Date.now() };
-        return testChatgpt(now.chatgpt, this.o.fetch ?? fetch);
+        const token = await this.state.planToken(caller.id, provider);
+        const now = await this.state.ownPlan(caller.id, provider);
+        if (!token || !now)
+            return now?.doc.test ?? { ok: false, detail: 'Sign in again.', at: Date.now() };
+        const test = await testChatgpt(now.doc.chatgpt, this.o.fetch ?? fetch);
+        await this.state.docs.write(caller.id, now.name, { ...now.doc, test });
+        return test;
     }
     /** One free call (reading a model) that says whether the provider takes the key. */
     async testKey(provider, apiKey) {

package/dist/assistant/routes.js

@@ -14,6 +14,9 @@
  *   PUT    /my-key/cap {cap_usd}    what the person may spend a month on their own keys
  *   POST   /my-signin               starts a ChatGPT plan sign-in (`?provider=openai`): {url, redirect}
  *   POST   /my-signin/finish {url}  finishes it from the 127.0.0.1 address the sign-in ended on
+ *   DELETE /my-signin               signs out of the plan (the person's key, if set, runs on)
+ *                                   (`POST /my-key/test?way=key|plan` tests one; the plan and the
+ *                                   key are kept side by side, `own_use` in /settings picks)
  *   PUT    /web/scrapeql {client_id, client_secret}, DELETE /web/scrapeql, POST /web/test   admin
  *   POST   /chat                    one answer as server-sent events; closing the request stops it
  *   GET    /chats, GET|DELETE /chats/:id
@@ -27,10 +30,10 @@
  * form or fetch is refused before it reaches a rule. Keys and tokens are write-only: no route
  * returns one, only a hint (`sk-ant-…abcd`).
  */
-import { ASSISTANT_ACCESS, ASSISTANT_EFFORTS, ASSISTANT_PAYERS, HAND_OFF_POLICIES, } from '@columenlabs/lumen-ui-types/assistant';
+import { ASSISTANT_ACCESS, ASSISTANT_EFFORTS, ASSISTANT_OWN_WAYS, ASSISTANT_PAYERS, HAND_OFF_POLICIES, } from '@columenlabs/lumen-ui-types/assistant';
 import { AssistantError } from './engine.js';
 import { PROVIDERS } from './models.js';
-import { keyDocName } from './state.js';
+import { keyDocName, planDocName } from './state.js';
 import { APP_SCOPE } from './store.js';
 const MUTATING = new Set(['POST', 'PUT', 'PATCH', 'DELETE']);
 const MAX_MESSAGE = 20_000;
@@ -101,6 +104,16 @@ function settingsChange(a, groups, b) {
         return 'web is {fetch: true | false}.';
     if (p.pay !== undefined && !oneOf(ASSISTANT_PAYERS, p.pay))
         return 'pay is app or own.';
+    if (p.own_use !== undefined) {
+        if (!p.own_use || typeof p.own_use !== 'object')
+            return 'own_use is {provider: key | plan}.';
+        for (const [prov, w] of Object.entries(p.own_use)) {
+            if (!a.providers.includes(prov))
+                return `No provider ${prov}.`;
+            if (!oneOf(ASSISTANT_OWN_WAYS, w))
+                return `No way ${w}.`;
+        }
+    }
     return (d) => {
         const tiers = { ...(d.tiers ?? {}) };
         for (const [id, t] of Object.entries(p.tiers ?? {})) {
@@ -118,6 +131,7 @@ function settingsChange(a, groups, b) {
             ...(p.access !== undefined ? { access: { ...(d.access ?? {}), ...p.access } } : {}),
             ...(p.web !== undefined ? { web: p.web.fetch } : {}),
             ...(p.pay !== undefined ? { pay: p.pay } : {}),
+            ...(p.own_use !== undefined ? { own_use: { ...(d.own_use ?? {}), ...p.own_use } } : {}),
         };
     };
 }
@@ -195,6 +209,10 @@ export function assistantRoutes(app, o) {
                     if (!test.ok)
                         return fail(test.detail, 400, 'key_refused');
                     const scope = mine ? caller.id : APP_SCOPE;
+                    // A plan sign-in from before 2026-10-27 sits in the key's doc: move it beside the key.
+                    const legacy = mine ? await a.state.ownPlan(caller.id, prov) : null;
+                    if (legacy?.name === docName)
+                        await docs.write(scope, planDocName(prov), legacy.doc);
                     await docs.write(scope, docName, { api_key: key, saved_at: Date.now(), test });
                     return status();
                 }
@@ -218,6 +236,9 @@ export function assistantRoutes(app, o) {
                 }
                 case 'POST /my-signin':
                     return json(await a.startSignin(caller, prov));
+                case 'DELETE /my-signin':
+                    await a.signOut(caller, prov);
+                    return status();
                 case 'POST /my-signin/finish': {
                     const pasted = str((await body(req)).url, 4000);
                     if (!pasted)
@@ -226,10 +247,13 @@ export function assistantRoutes(app, o) {
                     return status();
                 }
                 case 'POST /my-key/test': {
-                    const test = await a.testOwn(caller, prov);
+                    const askedWay = url.searchParams.get('way');
+                    const way = oneOf(ASSISTANT_OWN_WAYS, askedWay);
+                    if (askedWay !== null && !way)
+                        return fail('way is key or plan.');
+                    const test = await a.testOwn(caller, prov, way);
                     if (!test)
-                        return fail('No key is set.', 404);
-                    await docs.update(caller.id, docName, (d) => (d ? { ...d, test } : null));
+                        return fail(way === 'plan' ? 'Not signed in.' : 'No key is set.', 404);
                     return json(test);
                 }
                 case 'POST /key/test': {

package/dist/assistant/state.d.ts

@@ -19,7 +19,7 @@
  * tier runs on and money left this month, else the other; with neither the assistant waits and says
  * why. A cap covers every provider of its payer.
  */
-import type { AllowanceRequest, AssistantAccess, AssistantEffort, AssistantPayer, AssistantProvider, AssistantWait, HandOffPolicy, UsagePart } from '@columenlabs/lumen-ui-types/assistant';
+import type { AllowanceRequest, AssistantAccess, AssistantEffort, AssistantOwnWay, AssistantPayer, AssistantProvider, AssistantWait, HandOffPolicy, UsagePart } from '@columenlabs/lumen-ui-types/assistant';
 import { type ChatgptTokens } from './chatgpt.js';
 import { type Docs } from './store.js';
 export interface KeyTest {
@@ -38,6 +38,8 @@ export interface KeyDoc {
 }
 /** Where a provider's key is kept: `key` for Anthropic, `key:<provider>` for the rest. */
 export declare const keyDocName: (provider: AssistantProvider) => string;
+/** Where a person's plan sign-in is kept, beside their key (before 2026-10-27 it replaced the key). */
+export declare const planDocName: (provider: AssistantProvider) => string;
 export interface TokenDoc {
     client_id: string;
     client_secret: string;
@@ -62,6 +64,8 @@ export interface PersonDoc {
     pay?: AssistantPayer;
     /** USD a month on their own keys. */
     own_cap?: number;
+    /** Which of their own runs on a provider when both a key and a plan are set. */
+    own_use?: Partial<Record<AssistantProvider, AssistantOwnWay>>;
 }
 /** How the app counts allowance on its shared keys (`createAssistant` `allowance`). */
 export interface AllowanceConfig {
@@ -156,8 +160,20 @@ export declare class State {
         key: string;
         fromEnv: boolean;
     } | null>;
+    /** The person's own API key (a key doc that holds a plan sign-in is their plan). */
     ownKey(id: string, provider: AssistantProvider): Promise<KeyDoc | null>;
-    /** The person's own key, a plan sign-in refreshed first when it is about to run out. */
+    /** The person's plan sign-in and the doc it is kept in (the key's, for a sign-in from before). */
+    ownPlan(id: string, provider: AssistantProvider): Promise<{
+        doc: KeyDoc & {
+            chatgpt: ChatgptTokens;
+        };
+        name: string;
+    } | null>;
+    /** Which of their own runs: the one they picked while it is set, else the plan, else the key. */
+    ownUse(id: string, provider: AssistantProvider): Promise<AssistantOwnWay | null>;
+    /** The plan's access token, refreshed first when it is about to run out; null once it fails. */
+    planToken(id: string, provider: AssistantProvider): Promise<string | null>;
+    /** The person's own key or plan, the one in use first, the other when that one fails. */
     ownApiKey(id: string, provider: AssistantProvider): Promise<{
         key: string;
         plan: boolean;

package/dist/assistant/state.js

@@ -3,6 +3,8 @@ import { PROVIDERS, keyHint } from './models.js';
 import { APP_SCOPE } from './store.js';
 /** Where a provider's key is kept: `key` for Anthropic, `key:<provider>` for the rest. */
 export const keyDocName = (provider) => provider === 'anthropic' ? 'key' : `key:${provider}`;
+/** Where a person's plan sign-in is kept, beside their key (before 2026-10-27 it replaced the key). */
+export const planDocName = (provider) => `plan:${provider}`;
 /** Requests kept for approvers: the newest this many. */
 const REQUESTS_KEPT = 300;
 /** USD a month when nobody set a cap. */
@@ -107,35 +109,70 @@ export class State {
         const env = await this.o.appKey?.(provider);
         return env ? { key: env, fromEnv: true } : null;
     }
-    ownKey(id, provider) {
-        return this.docs.read(id, keyDocName(provider));
+    /** The person's own API key (a key doc that holds a plan sign-in is their plan). */
+    async ownKey(id, provider) {
+        const d = await this.docs.read(id, keyDocName(provider));
+        return d && !d.chatgpt ? d : null;
     }
-    /** The person's own key, a plan sign-in refreshed first when it is about to run out. */
-    async ownApiKey(id, provider) {
-        const d = await this.ownKey(id, provider);
-        if (!d)
+    /** The person's plan sign-in and the doc it is kept in (the key's, for a sign-in from before). */
+    async ownPlan(id, provider) {
+        for (const name of [planDocName(provider), keyDocName(provider)]) {
+            const doc = await this.docs.read(id, name);
+            if (doc?.chatgpt)
+                return { doc: doc, name };
+        }
+        return null;
+    }
+    /** Which of their own runs: the one they picked while it is set, else the plan, else the key. */
+    async ownUse(id, provider) {
+        const [p, key, plan] = await Promise.all([
+            this.person(id),
+            this.ownKey(id, provider),
+            this.ownPlan(id, provider),
+        ]);
+        const use = p.own_use?.[provider];
+        if (use === 'key' && key)
+            return 'key';
+        if (use === 'plan' && plan)
+            return 'plan';
+        return plan ? 'plan' : key ? 'key' : null;
+    }
+    /** The plan's access token, refreshed first when it is about to run out; null once it fails. */
+    async planToken(id, provider) {
+        const found = await this.ownPlan(id, provider);
+        if (!found)
             return null;
-        if (!d.chatgpt)
-            return { key: d.api_key, plan: false };
+        const { doc: d, name } = found;
         if (!staleChatgpt(d.chatgpt))
-            return { key: d.chatgpt.access_token, plan: true };
+            return d.chatgpt.access_token;
         try {
             const t = await refreshChatgpt(d.chatgpt, this.o.fetch ?? fetch);
-            await this.docs.write(id, keyDocName(provider), {
-                ...d,
-                api_key: t.access_token,
-                chatgpt: t,
-            });
-            return { key: t.access_token, plan: true };
+            await this.docs.write(id, name, { ...d, api_key: t.access_token, chatgpt: t });
+            return t.access_token;
         }
         catch (err) {
-            await this.docs.write(id, keyDocName(provider), {
+            await this.docs.write(id, name, {
                 ...d,
                 test: { at: Date.now(), ok: false, detail: err.message },
             });
             return null;
         }
     }
+    /** The person's own key or plan, the one in use first, the other when that one fails. */
+    async ownApiKey(id, provider) {
+        const use = await this.ownUse(id, provider);
+        if (!use)
+            return null;
+        const key = async () => {
+            const d = await this.ownKey(id, provider);
+            return d ? { key: d.api_key, plan: false } : null;
+        };
+        const plan = async () => {
+            const t = await this.planToken(id, provider);
+            return t ? { key: t, plan: true } : null;
+        };
+        return use === 'key' ? ((await key()) ?? (await plan())) : ((await plan()) ?? (await key()));
+    }
     /** USD a month on the person's own keys. */
     async ownCap(id) {
         const p = await this.person(id);

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.92",
+  "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.92",
-    "@columenlabs/lumen-ui-types": "0.1.92",
+    "@columenlabs/lumen-ops": "0.1.94",
+    "@columenlabs/lumen-ui-types": "0.1.94",
     "openai": "7.32.0",
     "zod": "^4.3.6"
   },