@columenlabs/lumen-ai 0.1.77 → 0.1.79

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';
@@ -92,6 +97,10 @@ function untilStopped(work, signal) {
     });
 }
 const newId = (prefix) => `${prefix}_${crypto.randomUUID().replaceAll('-', '').slice(0, 20)}`;
+/** Every tool line in a chat, those in hand-off sections included. */
+function stepsOf(items) {
+    return items.flatMap((i) => i.kind === 'step' ? [i] : i.kind === 'handoff' ? stepsOf(i.items) : []);
+}
 /** Every draft in a chat, those in hand-off sections included. */
 function draftsOf(items) {
     return items.flatMap((i) => i.kind === 'draft' ? [i] : i.kind === 'handoff' ? draftsOf(i.items) : []);
@@ -100,23 +109,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 +144,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 +153,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);
     }
@@ -177,20 +209,42 @@ export class Assistant {
         return (this.tierById(task === 'chat' ? (p.tier ?? startId) : startId) ?? this.tiers[0]);
     }
     access(p, g) {
-        return p.access?.[g.id] ?? g.access ?? 'read';
+        const a = p.access?.[g.id] ?? g.access ?? 'read';
+        return a === 'write' && !g.writes ? 'draft' : a;
+    }
+    groupById(id) {
+        return this.groups.find((g) => g.id === id);
     }
     // ---------------------------------------------------------------- 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 +254,28 @@ 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,
+            commands: (this.o.commands ?? []).map((c) => ({
+                name: c.name,
+                about: c.about,
+                ...(c.args ? { args: c.args } : {}),
+            })),
             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,
@@ -225,6 +288,7 @@ export class Assistant {
                 about: g.about,
                 access: this.access(p, g),
                 drafts: true,
+                writes: !!g.writes,
             })),
             hand_off: p.hand_off ?? 'next',
             advice: p.advice && (p.advice === 'off' || this.tierById(p.advice)) ? p.advice : 'off',
@@ -236,13 +300,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(),
@@ -317,12 +376,15 @@ export class Assistant {
         const fns = new Map();
         for (const o of opened)
             for (const def of o.open.tools) {
-                if (!def.read && o.access !== 'draft')
+                if (!def.read && o.access !== 'draft' && o.access !== 'write')
                     continue;
+                // Read + write on a group that offers no writes drafts.
+                const write = !def.read && o.access === 'write' && !!this.groupById(o.group)?.writes;
                 fns.set(toolName(o.group, def.name), {
                     group: o.group,
                     def,
-                    draft: !def.read,
+                    draft: !def.read && !write,
+                    write,
                     open: o.open,
                 });
             }
@@ -335,7 +397,7 @@ export class Assistant {
     toolsFor(fns) {
         return [...fns.entries()].map(([name, f]) => ({
             name,
-            description: `${f.draft ? "DRAFT ONLY: this call changes nothing. It puts a card on the person's screen that they Save or Dismiss. " : ''}${f.def.title ? `${f.def.title}. ` : ''}${f.def.description ?? ''}`.slice(0, 4000),
+            description: `${f.draft ? "DRAFT ONLY: this call changes nothing. It puts a card on the person's screen that they Save or Dismiss. " : f.write ? 'WRITES AT ONCE: this call makes the change now; the person can undo it. ' : ''}${f.def.title ? `${f.def.title}. ` : ''}${f.def.description ?? ''}`.slice(0, 4000),
             input_schema: { type: 'object', ...f.def.inputSchema },
         }));
     }
@@ -391,6 +453,7 @@ export class Assistant {
             history: [],
         };
         const compactOnly = message === '/compact';
+        const asked = await this.expand(caller, message);
         if (!compactOnly)
             doc.items.push({
                 kind: 'user',
@@ -402,20 +465,27 @@ export class Assistant {
             });
         const start = doc.items.length;
         emit('chat', { id: chatId, title: doc.title });
-        const { paying, wait } = await this.state.paying(caller.id);
+        // `tier` on a message: a higher one takes it as a task in its own section (handTo below); the
+        // same or a lower one answers it as the main tier, for this message only.
+        const picked = await this.mainTier(caller);
+        const lower = req.tier && !this.above(picked).some((t) => t.id === req.tier)
+            ? this.tierById(req.tier)
+            : undefined;
+        const main = await this.session(caller, lower ?? picked);
+        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;
@@ -433,7 +503,8 @@ export class Assistant {
         const handTo = req.tier ? this.above(main.tier).find((t) => t.id === req.tier) : undefined;
         const tools = await this.openTools(caller, p);
         const runs = [];
-        const counts = { steps: 0, handoffs: 0, advice: 0, end: main.tier };
+        doc.writes ??= {};
+        const counts = { steps: 0, handoffs: 0, advice: 0, end: main.tier, writes: doc.writes };
         let outcome = 'ok';
         try {
             const appSystem = typeof this.o.system === 'string' ? this.o.system : await this.o.system(caller);
@@ -451,7 +522,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) {
@@ -470,7 +541,7 @@ export class Assistant {
             }
             const page = this.cardNews(doc) +
                 (req.refs?.length
-                    ? `The person points at: ${JSON.stringify(req.refs).slice(0, 2000)}\n\n`
+                    ? `The person points at: ${JSON.stringify(req.refs).slice(0, 8000)}\n\n`
                     : '') +
                 (req.context
                     ? `Page: ${req.context.label}${req.context.note === undefined ? '' : `\n${JSON.stringify(req.context.note).slice(0, 4000)}`}\n\n`
@@ -480,11 +551,11 @@ export class Assistant {
                 : '';
             const messages = [
                 ...doc.history.map((t) => ({ role: t.role, content: t.content })),
-                { role: 'user', content: `${page}${lead}${message}` },
+                { role: 'user', content: `${page}${lead}${asked}` },
             ];
             const escalateTool = this.escalateTool(main.tier);
             let answer = await this.loop({
-                client,
+                clients,
                 session: main,
                 system,
                 tools: [...this.toolsFor(tools.fns), ...(escalateTool ? [escalateTool] : [])],
@@ -502,8 +573,8 @@ export class Assistant {
                 tool: (use) => use.name === 'escalate'
                     ? this.handOff(use, {
                         caller,
-                        client,
-                        message,
+                        clients,
+                        message: asked,
                         handTo,
                         page,
                         policy,
@@ -531,7 +602,7 @@ export class Assistant {
                 emit('text', { delta: answer });
                 emit('text_end', {});
             }
-            doc.history.push({ role: 'user', content: `${page}${message}` });
+            doc.history.push({ role: 'user', content: `${page}${asked}` });
             doc.history.push({ role: 'assistant', content: this.remember(answer, runs) });
         }
         catch (err) {
@@ -544,14 +615,14 @@ export class Assistant {
                     .map((i) => i.text)
                     .join('\n\n');
                 if (!compactOnly) {
-                    doc.history.push({ role: 'user', content: message });
+                    doc.history.push({ role: 'user', content: asked });
                     doc.history.push({ role: 'assistant', content: said || '(stopped before answering)' });
                 }
             }
             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),
@@ -594,6 +665,7 @@ export class Assistant {
             `You are ${this.name}. Today is ${new Date().toISOString().slice(0, 10)}.`,
             'Answer in short plain sentences. Use the tools for facts; never guess a number a tool can give you. Call several tools at once when they do not depend on each other.',
             'A tool marked DRAFT ONLY makes a card the person saves or dismisses; it changes nothing by itself. Say what the card will do; never claim it is done. The next message tells you how each card ended.',
+            'A tool marked WRITES AT ONCE makes its change when you call it; the person can undo it from the chat. Change only what they asked for, and say what you changed.',
         ];
         if (!fns.size)
             lines.push('No tools are on now: the person can turn them on in Settings ▸ Tools.');
@@ -615,10 +687,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`);
@@ -645,6 +720,17 @@ export class Assistant {
             },
         };
     }
+    /** What the model is asked: an app command's prompt, else the message as typed. */
+    async expand(caller, message) {
+        const m = /^\/([\w-]+)(?:\s+([\s\S]*))?$/.exec(message);
+        const c = m && this.o.commands?.find((x) => x.name === m[1]);
+        if (!c)
+            return message;
+        const args = (m?.[2] ?? '').trim();
+        return typeof c.prompt === 'function'
+            ? c.prompt(args, caller)
+            : c.prompt.replaceAll('{args}', args);
+    }
     /** The tiers the person's message asks for by name ("go deeper" is the next one up). */
     askedFor(message, main) {
         const reach = this.above(main);
@@ -682,6 +768,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 +795,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),
@@ -776,6 +864,8 @@ export class Assistant {
         let rows;
         try {
             const result = await untilStopped(withDeadline(title, 60_000, f.open.call(f.def.name, use.input)), signal);
+            if (f.write && counts.writes)
+                counts.writes[id] = { group: f.group, tool: f.def.name, args: use.input, result };
             rows = rowCount(result);
             out = typeof result === 'string' ? result : JSON.stringify(result);
         }
@@ -797,6 +887,9 @@ export class Assistant {
             ms,
             ...(rows !== undefined ? { rows } : {}),
             ...(error ? { error } : {}),
+            ...(f.write && ok
+                ? { write: { undo: !!this.groupById(f.group)?.undo, status: 'done' } }
+                : {}),
         };
         sink.push(item);
         emit('step', item);
@@ -816,7 +909,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 +1176,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.' },
@@ -967,10 +1228,16 @@ export class Assistant {
     cardNews(doc) {
         const told = new Set(doc.told ?? []);
         const news = draftsOf(doc.items).filter((d) => d.status !== 'open' && !told.has(d.id));
-        if (!news.length)
+        const undone = stepsOf(doc.items).filter((x) => x.write?.status === 'undone' && !told.has(x.id));
+        if (!news.length && !undone.length)
             return '';
-        doc.told = [...told, ...news.map((d) => d.id)];
-        return `Cards since your last answer:\n${news
+        doc.told = [...told, ...news.map((d) => d.id), ...undone.map((x) => x.id)];
+        const back = undone.length
+            ? `The person undid these changes you made: ${undone.map((x) => `${x.title} ${JSON.stringify(doc.writes?.[x.id]?.args ?? {}).slice(0, 300)}`).join('; ')}. Do not make them again unless asked.\n\n`
+            : '';
+        if (!news.length)
+            return back;
+        return `${back}Cards since your last answer:\n${news
             .map((d) => `- ${d.title} ${JSON.stringify(d.args).slice(0, 300)}: ${d.status}${d.error ? ` (${d.error})` : ''}${d.result !== undefined ? ` → ${JSON.stringify(d.result).slice(0, 300)}` : ''}`)
             .join('\n')}\n\n`;
     }
@@ -990,13 +1257,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 };
@@ -1036,9 +1351,9 @@ export class Assistant {
             const tools = await this.openTools(caller, p);
             try {
                 const f = tools.fns.get(d.tool);
-                if (!f?.draft) {
+                if (!f || f.def.read) {
                     d.status = 'failed';
-                    d.error = 'Its tools are no longer on Read + draft in Settings ▸ Tools.';
+                    d.error = 'Its tools are no longer on Read + draft or Read + write in Settings ▸ Tools.';
                 }
                 else {
                     try {
@@ -1058,6 +1373,30 @@ export class Assistant {
         await this.writeChat(caller, chatId, doc);
         return d;
     }
+    /** Takes back one change a write made at once, through its group's `undo`. */
+    async undoWrite(caller, chatId, stepId) {
+        const doc = await this.state.docs.read(caller.id, `chat:${chatId}`);
+        if (!doc)
+            throw new AssistantError('That chat is gone.', 'not_found', 404);
+        const step = stepsOf(doc.items).find((x) => x.id === stepId);
+        const w = doc.writes?.[stepId];
+        if (!step?.write || !w)
+            throw new AssistantError('That change is gone.', 'not_found', 404);
+        if (step.write.status === 'undone')
+            throw new AssistantError('That change is already undone.', 'settled', 409);
+        const g = this.groupById(w.group);
+        if (!g?.undo)
+            throw new AssistantError('That change cannot be undone here.', 'no_undo', 400);
+        try {
+            await withDeadline(`Undo ${step.title}`, 60_000, g.undo(caller, w));
+            step.write = { ...step.write, status: 'undone' };
+        }
+        catch (err) {
+            throw new AssistantError(err instanceof Error ? err.message.slice(0, 300) : 'Undo failed.', 'undo_failed', 502);
+        }
+        await this.writeChat(caller, chatId, doc);
+        return step;
+    }
 }
 export function createAssistant(o) {
     return new Assistant(o);