@columenlabs/lumen-ai 0.1.77 → 0.1.78

package/dist/assistant/engine.js

@@ -8,15 +8,20 @@
  *
  * Hand off: an `escalate` tool hands one task to a higher tier with the same tools, in its own
  * section of the chat, and its memo goes back. Advice: Anthropic's advisor tool lets a higher tier
- * read the chat and send a plan (it runs nothing), at most `ADVICE_MAX` an answer.
+ * read the chat and send a plan (it runs nothing), at most `ADVICE_MAX` an answer (Claude only).
+ *
+ * Providers: a tier runs a Claude model (Anthropic's Messages API) or an OpenAI model (the
+ * Responses API), each on its payer's key of that provider. A hand-off may cross providers.
  *
  * Spend: every call is priced at list price as it runs; past what its payer has left this month the
  * model must answer from what it has.
  */
 import Anthropic from '@anthropic-ai/sdk';
 import { HAND_OFF_WHYS } from '@columenlabs/lumen-ui-types/assistant';
-import { CLAUDE_MODELS, DEFAULT_OUT, Meter, effortParams, } from './models.js';
-import { DEFAULT_CAP, State, WAIT_TEXT, keyState } from './state.js';
+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 { Docs } from './store.js';
 import { ToolError, rowCount, toolName, withDeadline, } from './tools.js';
 import { scrapeqlTools, webFetchTools } from './web.js';
@@ -100,23 +105,27 @@ function draftsOf(items) {
 function shownError(err) {
     if (err instanceof AssistantError)
         return { message: err.message, code: err.code };
-    if (err instanceof Anthropic.APIError) {
-        if (err.status === 401)
-            return { message: 'The Claude key was refused.', code: 'key_refused' };
-        if (err.status === 429)
+    const api = err instanceof Anthropic.APIError
+        ? { who: 'Claude', status: err.status }
+        : err instanceof OpenAI.APIError
+            ? { who: 'OpenAI', status: err.status }
+            : null;
+    if (api) {
+        const { who, status } = api;
+        if (status === 401)
+            return { message: `The ${who} key was refused.`, code: 'key_refused' };
+        if (status === 429)
             return {
-                message: 'Claude is busy or the key hit its rate limit. Try again shortly.',
+                message: `${who} is busy or the key hit its rate limit. Try again shortly.`,
                 code: 'rate_limited',
             };
-        if (err.status === 529 || (err.status ?? 0) >= 500)
-            return { message: 'Claude is overloaded. Try again shortly.', code: 'overloaded' };
-        return {
-            message: `Claude refused the request (${err.status ?? 'error'}).`,
-            code: 'model_error',
-        };
+        if (status === 529 || (status ?? 0) >= 500)
+            return { message: `${who} is overloaded. Try again shortly.`, code: 'overloaded' };
+        return { message: `${who} refused the request (${status ?? 'error'}).`, code: 'model_error' };
     }
     return { message: 'Something went wrong while answering.', code: 'internal' };
 }
+const isApiError = (err) => err instanceof Anthropic.APIError || err instanceof OpenAI.APIError;
 export class Assistant {
     o;
     name;
@@ -131,7 +140,7 @@ export class Assistant {
             throw new Error('An assistant needs at least one tier');
         this.name = o.name;
         this.tiers = o.tiers;
-        this.models = o.models ?? CLAUDE_MODELS;
+        this.models = o.models ?? ALL_MODELS;
         this.tasks = o.tasks ?? [
             { id: 'chat', label: 'Chat', about: 'The side panel', tier: o.tiers[0].id },
         ];
@@ -140,12 +149,31 @@ export class Assistant {
             timeZone: o.timeZone ?? 'UTC',
             defaultCap: o.defaultCap ?? DEFAULT_CAP,
             ...(o.appKey ? { appKey: o.appKey } : {}),
+            ...(o.fetch ? { fetch: o.fetch } : {}),
         });
     }
-    client(apiKey) {
+    anthropic(apiKey) {
         const f = this.o.fetch;
         return new Anthropic({ apiKey, maxRetries: 1, ...(f ? { fetch: f } : {}) });
     }
+    openai(apiKey, plan = false) {
+        const f = this.o.fetch;
+        // A plan sign-in's calls are not retried: a usage limit is final for now.
+        return new OpenAI({ apiKey, maxRetries: plan ? 0 : 1, ...(f ? { fetch: f } : {}) });
+    }
+    clients(paying) {
+        const { keys, plans } = paying;
+        return {
+            ...(keys.anthropic ? { anthropic: this.anthropic(keys.anthropic) } : {}),
+            ...(keys.openai
+                ? { openai: this.openai(keys.openai, !!plans.openai), openaiPlan: !!plans.openai }
+                : {}),
+        };
+    }
+    /** The providers the app's models run on, in the order the models list them. */
+    get providers() {
+        return [...new Set(this.models.map((m) => m.provider))];
+    }
     tierById(id) {
         return this.tiers.find((t) => t.id === id);
     }
@@ -181,16 +209,34 @@ export class Assistant {
     }
     // ---------------------------------------------------------------- status and settings
     async status(caller) {
-        const [p, appDoc, appKey, own, scrapeql, spend, appCap, { paying, wait }, main] = await Promise.all([
+        const main = await this.mainTier(caller);
+        const mainModel = (await this.pick(caller, main)).model;
+        const [p, providers, scrapeql, spend, appCap, ownCap, { paying, wait }] = await Promise.all([
             this.state.person(caller.id),
-            this.state.appKey(),
-            this.state.appApiKey(),
-            this.state.ownKey(caller.id),
+            Promise.all(this.providers.map(async (id) => {
+                const [doc, key, own] = await Promise.all([
+                    this.state.appKey(id),
+                    this.state.appApiKey(id),
+                    this.state.ownKey(caller.id, id),
+                ]);
+                const app = caller.admin
+                    ? keyState(doc, (d) => d.api_key)
+                    : { set: !!key };
+                return {
+                    id,
+                    label: PROVIDERS[id].label,
+                    prefix: PROVIDERS[id].prefix,
+                    keys_url: PROVIDERS[id].keysUrl,
+                    ...(PROVIDERS[id].signin ? { signin: PROVIDERS[id].signin } : {}),
+                    app: { ...app, ...(key?.fromEnv ? { from_env: true } : {}) },
+                    own: keyState(own, (d) => d.api_key),
+                };
+            })),
             this.o.web?.scrapeql ? this.state.scrapeql() : Promise.resolve(null),
             this.state.spend(caller.id),
             this.state.appCap(),
-            this.state.paying(caller.id),
-            this.mainTier(caller),
+            this.state.ownCap(caller.id),
+            this.state.paying(caller.id, mainModel.provider),
         ]);
         const tiers = await Promise.all(this.tiers.map(async (t) => {
             const { model, effort } = await this.pick(caller, t);
@@ -200,19 +246,23 @@ export class Assistant {
                 about: t.about,
                 model: model.id,
                 model_label: model.label,
+                provider: model.provider,
                 effort,
             };
         }));
-        const appState = caller.admin
-            ? keyState(appDoc, (d) => d.api_key)
-            : { set: !!appKey };
         return {
             name: this.name,
             wait,
+            ...(wait ? { wait_provider: mainModel.provider } : {}),
             admin: caller.admin,
             tier: main.id,
             tiers,
-            models: this.models.map((m) => ({ id: m.id, label: m.label, group: m.group })),
+            models: this.models.map((m) => ({
+                id: m.id,
+                label: m.label,
+                group: m.group,
+                provider: m.provider,
+            })),
             tasks: this.tasks.map((t) => ({
                 id: t.id,
                 label: t.label,
@@ -236,13 +286,8 @@ export class Assistant {
                         : { set: !!scrapeql }
                     : null,
             },
-            keys: {
-                app: { ...appState, cap: appCap, ...(appKey?.fromEnv ? { from_env: true } : {}) },
-                own: {
-                    ...keyState(own, (d) => d.api_key),
-                    cap: own?.cap_usd ?? this.o.defaultCap ?? DEFAULT_CAP,
-                },
-            },
+            providers,
+            caps: { app: appCap, own: ownCap },
             pay: p.pay ?? 'app',
             spend: {
                 month: this.state.month(),
@@ -402,20 +447,21 @@ export class Assistant {
             });
         const start = doc.items.length;
         emit('chat', { id: chatId, title: doc.title });
-        const { paying, wait } = await this.state.paying(caller.id);
+        const main = await this.session(caller, await this.mainTier(caller));
+        const { paying, wait } = await this.state.paying(caller.id, main.model.provider);
         if (!paying) {
-            const text = WAIT_TEXT[wait ?? 'not_connected'];
-            doc.items.push({ kind: 'error', text, code: wait ?? 'not_connected' });
+            const code = wait ?? 'not_connected';
+            const text = waitText(code, main.model.provider);
+            doc.items.push({ kind: 'error', text, code });
             await this.writeChat(caller, chatId, doc);
-            emit('error', { message: text, code: wait });
+            emit('error', { message: text, code });
             emit('done', { id: chatId, usage: doc.usage ?? NO_USAGE });
             return;
         }
         const p = await this.state.person(caller.id);
-        const main = await this.session(caller, await this.mainTier(caller));
         const policy = p.hand_off ?? 'next';
         const advisor = await this.advisorFor(caller, p.advice, main);
-        const client = this.client(paying.apiKey);
+        const clients = this.clients(paying);
         const live = [main.meter, ...(advisor ? [advisor.session.meter] : [])];
         const before = doc.usage ?? NO_USAGE;
         let context = before.context;
@@ -451,7 +497,7 @@ export class Assistant {
                 },
             ];
             if (compactOnly || (before.context ?? 0) > COMPACT_AT) {
-                const did = await this.compact(client, main, doc, emit);
+                const did = await this.compact(clients, main, doc, emit);
                 if (did)
                     context = undefined;
                 if (compactOnly) {
@@ -484,7 +530,7 @@ export class Assistant {
             ];
             const escalateTool = this.escalateTool(main.tier);
             let answer = await this.loop({
-                client,
+                clients,
                 session: main,
                 system,
                 tools: [...this.toolsFor(tools.fns), ...(escalateTool ? [escalateTool] : [])],
@@ -502,7 +548,7 @@ export class Assistant {
                 tool: (use) => use.name === 'escalate'
                     ? this.handOff(use, {
                         caller,
-                        client,
+                        clients,
                         message,
                         handTo,
                         page,
@@ -551,7 +597,7 @@ export class Assistant {
             else {
                 outcome = 'error';
                 const shown = shownError(err);
-                if (!(err instanceof AssistantError) && !(err instanceof Anthropic.APIError))
+                if (!(err instanceof AssistantError) && !isApiError(err))
                     console.error(JSON.stringify({
                         event: 'assistant_error',
                         error: String(err?.stack ?? err).slice(0, 2000),
@@ -615,10 +661,13 @@ export class Assistant {
     /** The advisor for this answer, or null when off. Never weaker than the model it advises. */
     async advisorFor(caller, setting, main) {
         const tier = setting && setting !== 'off' ? this.tierById(setting) : undefined;
-        if (!tier)
+        if (!tier || main.model.provider !== 'anthropic')
             return null;
         const rank = (m) => this.models.indexOf(m);
         let session = await this.session(caller, tier);
+        // Anthropic's advisor tool runs a Claude model: another provider's tier advises nothing.
+        if (session.model.provider !== 'anthropic')
+            session = { ...main };
         if (rank(session.model) < rank(main.model))
             session = { ...main, meter: new Meter(main.model, '') };
         session.meter = new Meter(session.model, `${session.tier.label} · advice`);
@@ -682,6 +731,8 @@ export class Assistant {
         if (c.over())
             return reply('No money left for a higher tier this answer: answer yourself.', true);
         const sub = await this.session(c.caller, tier);
+        if (!c.clients[sub.model.provider])
+            return reply(`${tier.label} runs on ${PROVIDERS[sub.model.provider].label} and no ${PROVIDERS[sub.model.provider].label} key is set for whoever pays this answer: answer yourself.`, true);
         c.live.push(sub.meter);
         c.counts.handoffs += 1;
         if (this.tiers.indexOf(tier) > this.tiers.indexOf(c.counts.end))
@@ -707,7 +758,7 @@ export class Assistant {
         let failed;
         try {
             memo = await this.loop({
-                client: c.client,
+                clients: c.clients,
                 session: sub,
                 system: c.system,
                 tools: this.toolsFor(c.tools),
@@ -816,7 +867,156 @@ export class Assistant {
         return reply(cut, !ok);
     }
     /** Model calls and tool rounds until the model answers; returns its words. */
-    async loop(o) {
+    loop(o) {
+        const { provider } = o.session.model;
+        const label = PROVIDERS[provider].label;
+        if (provider === 'openai') {
+            if (!o.clients.openai)
+                throw new AssistantError(`No ${label} key is set for this answer.`, 'not_connected');
+            return this.loopOpenAI({ ...o, client: o.clients.openai, plan: !!o.clients.openaiPlan });
+        }
+        if (!o.clients.anthropic)
+            throw new AssistantError(`No ${label} key is set for this answer.`, 'not_connected');
+        return this.loopClaude({ ...o, client: o.clients.anthropic });
+    }
+    /** The loop on OpenAI's Responses API: the same tools, Stop, caps and rounds as Claude's. */
+    async loopOpenAI(o) {
+        const { client, session, tools, sink, emit, signal, plan } = o;
+        const instructions = o.system.map((b) => b.text).join('\n\n');
+        const fnTools = tools.map((t) => ({
+            type: 'function',
+            name: t.name,
+            description: t.description ?? null,
+            parameters: t.input_schema,
+            strict: false,
+        }));
+        // The chat so far is plain text turns; this answer's calls are appended as OpenAI items.
+        const input = o.messages.map((m) => ({
+            role: m.role,
+            content: typeof m.content === 'string'
+                ? m.content
+                : m.content
+                    .map((b) => (b.type === 'text' ? b.text : ''))
+                    .filter(Boolean)
+                    .join('\n'),
+        }));
+        let answer = '';
+        let force = o.first?.type === 'tool' ? { type: 'function', name: o.first.name } : undefined;
+        // A plan sign-in takes function tools only inside a namespace and no output cap.
+        const sent = (only) => {
+            const fns = only ? fnTools.filter((t) => t.name === only) : fnTools;
+            if (!plan)
+                return { tools: fns, max_output_tokens: session.tier.out ?? DEFAULT_OUT };
+            return {
+                tools: [
+                    {
+                        type: 'namespace',
+                        name: 'app',
+                        description: `${this.name}'s tools`,
+                        tools: fns.map(({ strict: _, ...t }) => t),
+                    },
+                ],
+            };
+        };
+        for (let round = 0; round < MAX_ROUNDS; round++) {
+            signal?.throwIfAborted();
+            const effort = session.effort === 'default' ? undefined : session.effort;
+            // On a plan a forced call is the one tool offered, with any call required.
+            const only = plan && typeof force === 'object' ? force.name : undefined;
+            const choice = only ? 'required' : force;
+            const stream = client.responses.stream({
+                model: session.model.id,
+                instructions,
+                input,
+                ...sent(only),
+                store: false,
+                stream: true,
+                include: ['reasoning.encrypted_content'],
+                ...(effort ? { reasoning: { effort } } : {}),
+                ...(choice ? { tool_choice: choice } : {}),
+            }, signal ? { signal } : {});
+            let partial = '';
+            stream.on('response.output_text.delta', (e) => {
+                partial += e.delta;
+                emit('text', { delta: e.delta });
+            });
+            const res = await stream.finalResponse().catch((err) => {
+                if (signal?.aborted && partial)
+                    sink.push({ kind: 'text', text: partial });
+                throw err;
+            });
+            if (res.status === 'failed') {
+                if (partial)
+                    sink.push({ kind: 'text', text: partial });
+                const code = res.error?.code ?? '';
+                throw new AssistantError(/usage_limit/.test(code)
+                    ? 'Your ChatGPT plan reached its usage limit for now: try again later, or pick another model.'
+                    : 'OpenAI could not finish the answer.', 'upstream');
+            }
+            const u = res.usage;
+            if (u) {
+                const read = u.input_tokens_details?.cached_tokens ?? 0;
+                const written = u.input_tokens_details?.cache_write_tokens ?? 0;
+                session.meter.add({
+                    input_tokens: Math.max(0, u.input_tokens - read - written),
+                    output_tokens: u.output_tokens,
+                    cache_read_input_tokens: read,
+                    cache_creation_input_tokens: written,
+                }, plan);
+                o.context?.(u.input_tokens + u.output_tokens);
+            }
+            o.called();
+            const cut = res.incomplete_details?.reason === 'max_output_tokens' ? ' …(cut)' : '';
+            if (cut)
+                emit('text', { delta: cut });
+            const text = (res.output_text ?? '') + cut;
+            if (text) {
+                answer += (answer ? '\n\n' : '') + text;
+                sink.push({ kind: 'text', text });
+                emit('text_end', {});
+            }
+            // Reasoning, words and calls go back as they came, so the model keeps its own thread.
+            input.push(...res.output);
+            const calls = res.output.filter((b) => b.type === 'function_call');
+            if (calls.length === 0)
+                break;
+            const results = await Promise.all(calls.map((c) => {
+                let args = {};
+                try {
+                    args = c.arguments ? JSON.parse(c.arguments) : {};
+                }
+                catch { }
+                const use = {
+                    type: 'tool_use',
+                    id: c.call_id,
+                    name: c.name,
+                    input: args,
+                };
+                return untilStopped(o.tool(use), signal);
+            }));
+            for (const r of results) {
+                const body = typeof r.content === 'string' ? r.content : JSON.stringify(r.content ?? '');
+                input.push({
+                    type: 'function_call_output',
+                    call_id: r.tool_use_id,
+                    output: r.is_error ? `Error: ${body}` : body,
+                });
+            }
+            force = undefined;
+            const limit = o.over();
+            const last = round === MAX_ROUNDS - 2;
+            if (limit || last) {
+                input.push({
+                    role: 'user',
+                    content: limit ?? 'No more tool calls: answer now from what you have.',
+                });
+                force = 'none';
+            }
+        }
+        return answer;
+    }
+    /** The loop on Anthropic's Messages API, with the advisor and prompt caching. */
+    async loopClaude(o) {
         const { client, session, system, tools, messages, sink, emit, signal } = o;
         let answer = '';
         let force = o.first;
@@ -934,27 +1134,46 @@ export class Assistant {
         return answer;
     }
     /** Swaps the history for a short summary. False with nothing to compact. */
-    async compact(client, s, doc, emit) {
+    async compact(clients, s, doc, emit) {
         if (doc.history.length < 2)
             return false;
-        const msg = await client.messages.create({
-            model: s.model.id,
-            max_tokens: 1500,
-            system: `Summarise this chat between a person and ${this.name}, their assistant, so ${this.name} can carry on from the summary alone. Keep what the person wants, the facts and numbers found, decisions made and cards drafted or saved, and anything still open. Plain bullets, at most 400 words. No preamble.`,
-            messages: [
-                {
-                    role: 'user',
-                    content: doc.history
-                        .map((t) => `${t.role === 'user' ? 'Person' : this.name}: ${t.content}`)
-                        .join('\n\n'),
-                },
-            ],
-        });
-        s.meter.add(msg.usage);
-        const summary = msg.content
-            .filter((b) => b.type === 'text')
-            .map((b) => b.text)
-            .join('');
+        const system = `Summarise this chat between a person and ${this.name}, their assistant, so ${this.name} can carry on from the summary alone. Keep what the person wants, the facts and numbers found, decisions made and cards drafted or saved, and anything still open. Plain bullets, at most 400 words. No preamble.`;
+        const chat = doc.history
+            .map((t) => `${t.role === 'user' ? 'Person' : this.name}: ${t.content}`)
+            .join('\n\n');
+        let summary = '';
+        if (s.model.provider === 'openai' && clients.openai) {
+            const res = await clients.openai.responses.create({
+                model: s.model.id,
+                instructions: system,
+                input: chat,
+                store: false,
+                max_output_tokens: 1500,
+            });
+            const u = res.usage;
+            if (u)
+                s.meter.add({
+                    input_tokens: u.input_tokens - (u.input_tokens_details?.cached_tokens ?? 0),
+                    output_tokens: u.output_tokens,
+                    cache_read_input_tokens: u.input_tokens_details?.cached_tokens ?? 0,
+                });
+            summary = res.output_text ?? '';
+        }
+        else if (clients.anthropic) {
+            const msg = await clients.anthropic.messages.create({
+                model: s.model.id,
+                max_tokens: 1500,
+                system,
+                messages: [{ role: 'user', content: chat }],
+            });
+            s.meter.add(msg.usage);
+            summary = msg.content
+                .filter((b) => b.type === 'text')
+                .map((b) => b.text)
+                .join('');
+        }
+        else
+            return false;
         doc.history = [
             { role: 'user', content: `Summary of our chat so far (compacted):\n${summary}` },
             { role: 'assistant', content: 'Noted. I carry on from this summary.' },
@@ -990,13 +1209,61 @@ export class Assistant {
         return `${answer}\n\n[Tools I used and what they returned]\n${lines.join('\n')}`;
     }
     // ---------------------------------------------------------------- keys
-    /** One free call (reading a model) that says whether Claude takes the key. */
-    async testKey(apiKey) {
+    /** Starts a person's ChatGPT plan sign-in: the address to open in a new tab. */
+    async startSignin(caller, provider) {
+        if (PROVIDERS[provider].signin !== 'chatgpt')
+            throw new AssistantError(`${PROVIDERS[provider].label} has no sign-in.`, 'no_signin', 404);
+        const name = `signin:${provider}`;
+        const { url, reg } = await startChatgpt(await this.state.docs.read(caller.id, name), this.name);
+        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. */
+    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), {
+                api_key: tokens.access_token,
+                saved_at: Date.now(),
+                test,
+                chatgpt: tokens,
+            });
+        }
+        catch (err) {
+            if (err instanceof SigninError)
+                throw new AssistantError(err.message, 'signin_failed');
+            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)
+            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);
+    }
+    /** One free call (reading a model) that says whether the provider takes the key. */
+    async testKey(provider, apiKey) {
         const at = Date.now();
-        const model = this.modelById(this.tiers[0].model) ?? this.models[0];
+        const model = this.models.find((m) => m.provider === provider);
+        const label = PROVIDERS[provider].label;
+        if (!model)
+            return { ok: false, detail: `This app runs no ${label} models.`, at };
         try {
-            await this.client(apiKey).models.retrieve(model.id);
-            return { ok: true, detail: 'Claude took the key.', at };
+            if (provider === 'openai')
+                await this.openai(apiKey).models.retrieve(model.id);
+            else
+                await this.anthropic(apiKey).models.retrieve(model.id);
+            return { ok: true, detail: `${label} took the key.`, at };
         }
         catch (err) {
             return { ok: false, detail: shownError(err).message, at };

package/dist/assistant/index.d.ts

@@ -1,6 +1,6 @@
 /**
- * An assistant for any app: a chat side panel's server. Claude on the app's tiers (named by the
- * app), the app's tools from any MCP server, the web (a plain fetch and ScrapeQL over its API),
+ * An assistant for any app: a chat side panel's server. Claude or OpenAI models on the app's tiers
+ * (named by the app), the app's tools from any MCP server, the web (a plain fetch and ScrapeQL over its API),
  * hand off to a higher tier, advice, drafts the person saves, and a monthly spend cap per person.
  *
  *   const assistant = createAssistant({ name, system, tiers, groups, store, sealer, appKey });
@@ -12,7 +12,7 @@
 export * from './engine.js';
 export * from './models.js';
 export * from './routes.js';
-export { DEFAULT_CAP, type KeyDoc, type KeyTest, monthIn, type Paying, type PersonDoc, type SpendDoc, State, type TokenDoc, } from './state.js';
+export { DEFAULT_CAP, type KeyDoc, keyDocName, type KeyTest, monthIn, type Paying, type PersonDoc, type SpendDoc, State, type TokenDoc, waitText, } from './state.js';
 export * from './store.js';
 export * from './tools.js';
 export * from './web.js';

package/dist/assistant/index.js

@@ -1,6 +1,6 @@
 /**
- * An assistant for any app: a chat side panel's server. Claude on the app's tiers (named by the
- * app), the app's tools from any MCP server, the web (a plain fetch and ScrapeQL over its API),
+ * An assistant for any app: a chat side panel's server. Claude or OpenAI models on the app's tiers
+ * (named by the app), the app's tools from any MCP server, the web (a plain fetch and ScrapeQL over its API),
  * hand off to a higher tier, advice, drafts the person saves, and a monthly spend cap per person.
  *
  *   const assistant = createAssistant({ name, system, tiers, groups, store, sealer, appKey });
@@ -12,7 +12,7 @@
 export * from './engine.js';
 export * from './models.js';
 export * from './routes.js';
-export { DEFAULT_CAP, monthIn, State, } from './state.js';
+export { DEFAULT_CAP, keyDocName, monthIn, State, waitText, } from './state.js';
 export * from './store.js';
 export * from './tools.js';
 export * from './web.js';

package/dist/assistant/models.d.ts

@@ -3,11 +3,13 @@
  * person may pick another model and effort per tier. Prices are the providers' list prices per
  * million tokens, so every answer's cost is known as it runs.
  */
-import type { AssistantEffort, UsagePart } from '@columenlabs/lumen-ui-types/assistant';
+import type { AssistantEffort, AssistantProvider, UsagePart } from '@columenlabs/lumen-ui-types/assistant';
 /** A model a tier can run, with its list price per million tokens (input, output, cache reads). */
 export interface ModelDef {
     id: string;
     label: string;
+    /** Whose key runs it. */
+    provider: AssistantProvider;
     /** The heading pickers list it under (its provider). */
     group: string;
     in: number;
@@ -16,6 +18,17 @@ export interface ModelDef {
 }
 /** Claude models, smallest first (an advisor is never weaker than the model it advises). */
 export declare const CLAUDE_MODELS: ModelDef[];
+/** OpenAI models, smallest first (list prices from OpenAI's pricing page, October 2026). */
+export declare const OPENAI_MODELS: ModelDef[];
+/** Every model the kit knows: what a tier may run unless the app lists its own. */
+export declare const ALL_MODELS: ModelDef[];
+/** How Settings names each provider, how its keys start and where a person makes one. */
+export declare const PROVIDERS: Record<AssistantProvider, {
+    label: string;
+    prefix: string;
+    keysUrl: string;
+    signin?: 'chatgpt';
+}>;
 /** A tier as the app defines it. `out` caps each model call's output tokens. */
 export interface TierDef {
     id: string;
@@ -57,7 +70,8 @@ export declare class Meter {
     out: number;
     usd: number;
     constructor(model: ModelDef, label: string);
-    add(usage: TokenUsage): void;
+    /** `free`: the call ran on a plan sign-in, so it counts tokens and no dollars. */
+    add(usage: TokenUsage, free?: boolean): void;
     part(): UsagePart;
 }
 /** The request's effort setting: nothing at the model's own default. */