@columenlabs/lumen-ai 0.1.186 → 0.1.188

package/dist/assistant/engine.js

@@ -1,17 +1,8 @@
 /**
- * The assistant: one turn loop for any app, ported from a production assistant.
- *
- * A turn streams the model's words and runs its tool calls until it answers (at most `MAX_ROUNDS`
- * rounds). A write tool only drafts: a card the person saves or dismisses. Stop aborts the model
- * and any running tool at once and keeps what was said. Past `COMPACT_AT` tokens (or on
- * `/compact`) the history sent to the model becomes a short summary; the screen keeps every message.
- *
- * 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 (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.
+ * The assistant: what every chat shares, for any app. Its tiers, tasks and models, who pays and
+ * their caps, keys and the ChatGPT sign-in, tool groups and their access, the allowance, background
+ * answers (`complete`) and the plan each agent turn runs on (`agentTurn`). The chat itself runs on
+ * the agent (`../agent`, LumenAgent); chats saved by the old turn loop stay readable until purged.
  *
  * 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.
@@ -26,7 +17,7 @@ import { CHATGPT_REDIRECT, SigninError, finishChatgpt, startChatgpt, testChatgpt
 import { ALL_MODELS, DEFAULT_OUT, Meter, PROVIDERS, effortParams, } from './models.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 { toolName, withDeadline } from './tools.js';
 import { scrapeqlTools, webFetchTools } from './web.js';
 const DOLLARS = { one: 'dollar', many: 'dollars', usd: 1 };
 const round2 = (n) => Math.round(n * 100) / 100;
@@ -43,28 +34,11 @@ export class AssistantError extends Error {
     }
 }
 const MAX_ROUNDS = 8;
-const COMPACT_AT = 150_000;
-/** A tool result handed to the model is cut past this (about 4,000 tokens). */
-const RESULT_CHARS = 16_000;
 const MEMO_CHARS = 8000;
 /** The built-in tool that runs several reads at once, as one step. */
 const BATCH = 'batch';
-const BATCH_MAX = 25;
-/** What one batch returns at most, all its results together. */
-const BATCH_CHARS = 48_000;
 const ADVICE_MAX = 2;
 const ADVICE_TOKENS = 2048;
-const ADVISOR_BETA = 'advisor-tool-2026-03-01';
-/**
- * What later turns remember of the tools' results, so a follow-up ("list them all", "which have no
- * milk") answers from what was read instead of calling the same tools again. Each result is kept
- * as the model saw it (`RAN_CHARS`), at most `RAN_TURN` a turn as stored, and the whole chat sends
- * at most `RAN_CHAT`: newest first, a call repeated later kept only in its latest turn, and past
- * the budget an older result is named but dropped, so a long chat costs no more than a short one.
- */
-const RAN_CHARS = RESULT_CHARS;
-const RAN_TURN = 40_000;
-const RAN_CHAT = 40_000;
 const CHATS_LISTED = 200;
 const WHY_TEXT = {
     asked: 'you asked',
@@ -72,110 +46,6 @@ const WHY_TEXT = {
     stuck: 'stuck',
     check_failed: 'check failed',
 };
-/** JSON with object keys sorted, so the same input written in another order is the same call. */
-function stableJson(v) {
-    return JSON.stringify(v, (_k, x) => x && typeof x === 'object' && !Array.isArray(x)
-        ? Object.fromEntries(Object.entries(x).sort(([a], [b]) => (a < b ? -1 : a > b ? 1 : 0)))
-        : x);
-}
-/** A turn's tool results as stored: each cut to what the model saw, the turn to `RAN_TURN`. */
-function ranOf(runs) {
-    let left = RAN_TURN;
-    const ran = [];
-    for (const r of runs) {
-        if (left <= 0)
-            break;
-        const result = r.result.slice(0, Math.min(RAN_CHARS, left));
-        left -= result.length;
-        ran.push({ ...r, result: result.length < r.result.length ? `${result} …(cut)` : result });
-    }
-    return ran.length ? { ran } : {};
-}
-/**
- * The history as sent: each answer followed by what its tools returned, within `RAN_CHAT` for the
- * whole chat, newest first. A call made again later is kept only there; one past the budget is
- * named so the model knows to call it again. Chats stored before `ran` carry it in `content`.
- */
-function toolMemory(history) {
-    let left = RAN_CHAT;
-    const later = new Set();
-    const out = [];
-    for (let i = history.length - 1; i >= 0; i--) {
-        const t = history[i];
-        if (!t.ran?.length) {
-            out.push({ role: t.role, content: t.content });
-            continue;
-        }
-        const lines = t.ran.map((r) => {
-            if (r.key && later.has(r.key))
-                return `- ${r.tool} → (called again later; see there)`;
-            if (r.key)
-                later.add(r.key);
-            if (left < 200)
-                return `- ${r.tool} → (no longer kept; call it again if you need it)`;
-            const kept = r.result.slice(0, left);
-            left -= kept.length;
-            return `- ${r.tool} → ${kept}${kept.length < r.result.length ? ' …(cut)' : ''}`;
-        });
-        out.push({
-            role: t.role,
-            content: `${t.content}\n\n[Tools I used and what they returned]\n${lines.join('\n')}`,
-        });
-    }
-    return out.reverse();
-}
-const NO_USAGE = { calls: 0, in: 0, read: 0, out: 0, usd: 0, parts: [] };
-function addUsage(u, parts) {
-    const out = { ...u, parts: u.parts.map((p) => ({ ...p })) };
-    for (const p of parts) {
-        if (!p.calls)
-            continue;
-        out.calls += p.calls;
-        out.in += p.in;
-        out.read += p.read;
-        out.out += p.out;
-        out.usd += p.usd;
-        const prev = out.parts.find((x) => x.label === p.label);
-        if (prev) {
-            prev.calls += p.calls;
-            prev.in += p.in;
-            prev.read += p.read;
-            prev.out += p.out;
-            prev.usd += p.usd;
-        }
-        else
-            out.parts.push({ ...p });
-    }
-    return out;
-}
-function withCacheMark(m) {
-    const blocks = typeof m.content === 'string' ? [{ type: 'text', text: m.content }] : [...m.content];
-    const last = blocks[blocks.length - 1];
-    if (!last || last.type === 'thinking' || last.type === 'redacted_thinking')
-        return m;
-    blocks[blocks.length - 1] = { ...last, cache_control: { type: 'ephemeral' } };
-    return { ...m, content: blocks };
-}
-/** A tool's result, or Stop's abort as soon as it comes. */
-function untilStopped(work, signal) {
-    if (!signal)
-        return work;
-    signal.throwIfAborted();
-    return new Promise((done, fail) => {
-        const stop = () => fail(signal.reason);
-        signal.addEventListener('abort', stop, { once: true });
-        work.then(done, fail).finally(() => signal.removeEventListener('abort', stop));
-    });
-}
-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) : []);
-}
 /** A short line of what an error was, never an upstream body. */
 function shownError(err) {
     if (err instanceof AssistantError)
@@ -222,15 +92,6 @@ function openaiStreamError(code, plan) {
         return 'OpenAI declined to answer this message.';
     return `OpenAI could not answer (${code || 'no reason given'}). It is logged; try again or pick another model.`;
 }
-/** A tool's schema without JSON Schema's `$schema` line, which zod writes and no provider needs. */
-const withoutMeta = (schema) => {
-    const { $schema: _, ...rest } = schema ?? {};
-    return rest;
-};
-/** Whether a response's output has words or a call to show. */
-const shows = (output) => output.some((b) => b.type === 'function_call' ||
-    (b.type === 'message' && b.content.some((c) => c.type === 'output_text' && c.text)));
-const isApiError = (err) => err instanceof Anthropic.APIError || err instanceof OpenAI.APIError;
 /**
  * The tools of a Think turn as the rules describe them. Think calls several tools in one step on
  * its own, so the kit's batch tool is not offered and its line is left out (`batch`).
@@ -244,16 +105,6 @@ function openedSummary(t) {
         web: t.info.some((i) => i.group === 'web'),
     };
 }
-function summarize(fns) {
-    const all = [...fns.values()];
-    return {
-        size: fns.size,
-        find: all.some((f) => f.def.find),
-        reads: all.some((f) => !f.draft && !f.write),
-        batch: fns.has(BATCH),
-        web: all.some((f) => f.group === 'web'),
-    };
-}
 export class Assistant {
     o;
     name;
@@ -388,6 +239,13 @@ export class Assistant {
             return apiKey ? { apiKey, ...(paying.plans[provider] ? { plan: true } : {}) } : null;
         };
         const key = keyOf(main.model.provider) ?? { apiKey: paying.apiKey };
+        // A ChatGPT plan used up for now: the app's first Claude (its smallest) answers instead, on
+        // the same payer's Anthropic key, rather than the turn ending in the limit's error.
+        const claude = key.plan ? this.models.find((m) => m.provider === 'anthropic') : undefined;
+        const claudeKey = claude ? keyOf('anthropic') : null;
+        const fallback = claude && claudeKey
+            ? { model: claude, key: claudeKey, label: `${main.tier.label} · ${claude.label}` }
+            : undefined;
         const p = await this.state.person(caller.id);
         const policy = p.hand_off ?? 'next';
         const advisor = await this.advisorFor(caller, p.advice, main);
@@ -423,6 +281,7 @@ export class Assistant {
                 ? `The person handed this message to ${handTo.label}: call escalate {tier: "${handTo.id}", why: "asked"} now, its task the message with every fact from this chat it needs, then answer from its memo.\n\n`
                 : ''}${command}`,
             sources: await this.sourcesOf(caller, p),
+            ...(fallback ? { fallback } : {}),
             left: paying.left,
             maxSteps: MAX_ROUNDS,
             ...(this.o.fetch ? { fetch: this.o.fetch } : {}),
@@ -846,9 +705,6 @@ export class Assistant {
     purge() {
         return this.o.store.purge('chat:', Date.now() - (this.o.keepDays ?? 30) * 86_400_000);
     }
-    writeChat(caller, id, doc) {
-        return this.state.docs.write(caller.id, `chat:${id}`, { ...doc, at: Date.now() }, doc.title);
-    }
     // ---------------------------------------------------------------- tools
     /** Opens the tools the person allows: each group's, then the web's. */
     /** The tool groups (and the web) at the person's access, not opened yet. */
@@ -880,354 +736,7 @@ export class Assistant {
         }
         return sources;
     }
-    async openTools(caller, p) {
-        const opened = [];
-        const sources = await this.sourcesOf(caller, p);
-        const results = await Promise.allSettled(sources.map((s) => s.source()));
-        results.forEach((r, i) => {
-            const s = sources[i];
-            if (r.status === 'fulfilled' && s)
-                opened.push({ group: s.group, access: s.access, open: r.value });
-        });
-        const fns = new Map();
-        for (const o of opened)
-            for (const def of o.open.tools) {
-                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 && !write,
-                    write,
-                    open: o.open,
-                });
-            }
-        return {
-            fns,
-            failed: results.filter((r) => r.status === 'rejected').length,
-            close: () => Promise.all(opened.map((o) => o.open.close().catch(() => undefined))),
-        };
-    }
-    toolsFor(fns) {
-        const batch = this.batchTool(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.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',
-                    ...withoutMeta(f.def.inputSchema),
-                },
-            })),
-            ...(batch ? [batch] : []),
-        ];
-    }
-    /** `batch`: any of the reads, up to BATCH_MAX at once, as one step. Null with no reads. */
-    batchTool(fns) {
-        if (fns.has(BATCH))
-            return null;
-        const reads = [...fns.entries()].filter(([, f]) => !f.draft && !f.write).map(([n]) => n);
-        if (!reads.length)
-            return null;
-        return {
-            name: BATCH,
-            description: `Runs up to ${BATCH_MAX} read calls at once and returns each result, numbered in order. Use it to read several records (one tool with several inputs) or several tools that do not depend on each other, in one step instead of one call at a time. Reads only.`,
-            input_schema: {
-                type: 'object',
-                properties: {
-                    calls: {
-                        type: 'array',
-                        minItems: 1,
-                        maxItems: BATCH_MAX,
-                        items: {
-                            type: 'object',
-                            properties: {
-                                tool: { type: 'string', enum: reads },
-                                input: { type: 'object', description: "The tool's own input." },
-                            },
-                            required: ['tool', 'input'],
-                        },
-                    },
-                },
-                required: ['calls'],
-            },
-        };
-    }
     // ---------------------------------------------------------------- the turn
-    /** One answer as server-sent events. Abort `signal` to stop it. */
-    turnStream(caller, req, signal) {
-        const enc = new TextEncoder();
-        let ctl;
-        let closed = false;
-        const stream = new ReadableStream({
-            start: (c) => {
-                ctl = c;
-            },
-            cancel: () => {
-                closed = true;
-            },
-        });
-        const emit = (event, data) => {
-            if (closed)
-                return;
-            try {
-                ctl.enqueue(enc.encode(`event: ${event}\ndata: ${JSON.stringify(data)}\n\n`));
-            }
-            catch {
-                closed = true;
-            }
-        };
-        void this.turn(caller, req, emit, signal).finally(() => {
-            if (closed)
-                return;
-            closed = true;
-            try {
-                ctl.close();
-            }
-            catch { }
-        });
-        return stream;
-    }
-    async turn(caller, req, emit, signal) {
-        const t0 = performance.now();
-        const message = req.message.trim();
-        const chatId = req.chat_id ?? newId('ac');
-        const prev = req.chat_id
-            ? await this.state.docs.read(caller.id, `chat:${req.chat_id}`)
-            : null;
-        if (req.chat_id && !prev) {
-            emit('error', { message: 'That chat is gone.', code: 'not_found' });
-            return;
-        }
-        const doc = prev ?? {
-            title: message.replace(/\s+/g, ' ').slice(0, 60),
-            items: [],
-            history: [],
-        };
-        const compactOnly = message === '/compact';
-        const asked = await this.expand(caller, message);
-        if (!compactOnly)
-            doc.items.push({
-                kind: 'user',
-                text: message,
-                at: Date.now(),
-                ...(req.context?.label ? { context: req.context.label } : {}),
-                ...(req.refs?.length ? { refs: req.refs } : {}),
-                ...(req.tier ? { tier: req.tier } : {}),
-            });
-        const start = doc.items.length;
-        emit('chat', { id: chatId, title: doc.title });
-        // `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 code = wait ?? 'not_connected';
-            const text = waitText(code, main.model.provider, !!this.o.allowance);
-            doc.items.push({ kind: 'error', text, code });
-            await this.writeChat(caller, chatId, doc);
-            emit('error', { message: text, code });
-            emit('done', { id: chatId, usage: doc.usage ?? NO_USAGE });
-            return;
-        }
-        const p = await this.state.person(caller.id);
-        const policy = p.hand_off ?? 'next';
-        const advisor = await this.advisorFor(caller, p.advice, main);
-        const clients = this.clients(paying);
-        const live = [main.meter, ...(advisor ? [advisor.session.meter] : [])];
-        const before = doc.usage ?? NO_USAGE;
-        let context = before.context;
-        const spent = () => ({
-            ...addUsage(before, live.map((m) => m.part())),
-            ...(context ? { context } : {}),
-        });
-        let limited = false;
-        const over = () => {
-            if (live.reduce((a, m) => a + m.usd, 0) < paying.left)
-                return null;
-            limited = true;
-            return 'The spend cap for this month is reached: answer now from what you have, in a sentence or two. You can call no more tools.';
-        };
-        const handTo = req.tier ? this.above(main.tier).find((t) => t.id === req.tier) : undefined;
-        const tools = await this.openTools(caller, p);
-        const runs = [];
-        doc.writes ??= {};
-        const counts = {
-            steps: 0,
-            handoffs: 0,
-            advice: 0,
-            end: main.tier,
-            writes: doc.writes,
-            seen: new Map(),
-        };
-        let outcome = 'ok';
-        try {
-            const appSystem = typeof this.o.system === 'string' ? this.o.system : await this.o.system(caller);
-            const kitRules = this.rules(main, policy, advisor, summarize(tools.fns), tools.failed);
-            const system = [
-                { type: 'text', text: appSystem },
-                { type: 'text', text: kitRules, cache_control: { type: 'ephemeral' } },
-            ];
-            const subSystem = [
-                { type: 'text', text: appSystem },
-                {
-                    type: 'text',
-                    text: this.rules(null, policy, null, summarize(tools.fns), tools.failed),
-                    cache_control: { type: 'ephemeral' },
-                },
-            ];
-            if (compactOnly || (before.context ?? 0) > COMPACT_AT) {
-                const did = await this.compact(clients, main, doc, emit);
-                if (did)
-                    context = undefined;
-                if (compactOnly) {
-                    if (!did) {
-                        const text = 'Nothing to compact yet.';
-                        doc.items.push({ kind: 'text', text });
-                        emit('text', { delta: text });
-                        emit('text_end', {});
-                    }
-                    doc.usage = spent();
-                    await this.writeChat(caller, chatId, doc);
-                    await this.state.addSpend(caller.id, paying.payer, live.map((m) => m.part()));
-                    emit('done', { id: chatId, usage: doc.usage });
-                    return;
-                }
-            }
-            const told = await bearings({
-                timeZone: req.time_zone,
-                fallbackZone: this.o.timeZone,
-                lastAt: prev?.at,
-                app: this.o.app,
-                ...(this.o.bearings ? { extras: (b) => this.o.bearings?.(b, caller) } : {}),
-            });
-            const page = told +
-                this.cardNews(doc) +
-                (req.refs?.length
-                    ? `The person points at these parts: they are what "this" means, and when the person asks for a change they are the only parts to change. Read anything else you need (the rest of the page, other records, your tools) for context, but leave it as it is unless they ask.\n${JSON.stringify(req.refs).slice(0, 16000)}\n\n`
-                    : '') +
-                (req.context
-                    ? `Page: ${req.context.label}${req.context.note === undefined ? '' : `\n${JSON.stringify(req.context.note).slice(0, 4000)}`}\n\n`
-                    : '');
-            const lead = handTo
-                ? `The person handed this message to ${handTo.label}: call escalate {tier: "${handTo.id}", why: "asked"} now, its task the message with every fact from this chat it needs, then answer from its memo.\n\n`
-                : '';
-            const messages = [
-                ...toolMemory(doc.history),
-                { role: 'user', content: `${page}${lead}${asked}` },
-            ];
-            const escalateTool = this.escalateTool(main.tier);
-            let answer = await this.loop({
-                clients,
-                session: main,
-                system,
-                tools: [...this.toolsFor(tools.fns), ...(escalateTool ? [escalateTool] : [])],
-                messages,
-                sink: doc.items,
-                emit,
-                signal,
-                over,
-                ...(handTo && escalateTool ? { first: { type: 'tool', name: 'escalate' } } : {}),
-                ...(advisor ? { advisor } : {}),
-                context: (n) => {
-                    context = n;
-                },
-                called: () => emit('usage', spent()),
-                tool: (use) => use.name === 'escalate'
-                    ? this.handOff(use, {
-                        caller,
-                        clients,
-                        message: asked,
-                        handTo,
-                        page,
-                        policy,
-                        main,
-                        live,
-                        sink: doc.items,
-                        emit,
-                        spent,
-                        system: subSystem,
-                        tools: tools.fns,
-                        runs,
-                        counts,
-                        signal,
-                        over,
-                    })
-                    : this.runTool(use, tools.fns, doc.items, emit, runs, counts, main, false, signal),
-            });
-            if (limited) {
-                doc.items.push({ kind: 'stopped', reason: 'cap' });
-                emit('stopped', { reason: 'cap' });
-            }
-            if (!answer) {
-                answer = 'I could not finish that. Try a narrower question.';
-                doc.items.push({ kind: 'text', text: answer });
-                emit('text', { delta: answer });
-                emit('text_end', {});
-            }
-            doc.history.push({ role: 'user', content: `${page}${asked}` });
-            doc.history.push({ role: 'assistant', content: answer, ...ranOf(runs) });
-        }
-        catch (err) {
-            if (signal?.aborted) {
-                outcome = 'stopped';
-                doc.items.push({ kind: 'stopped' });
-                const said = doc.items
-                    .slice(start)
-                    .filter((i) => i.kind === 'text')
-                    .map((i) => i.text)
-                    .join('\n\n');
-                if (!compactOnly) {
-                    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) && !isApiError(err))
-                    console.error(JSON.stringify({
-                        event: 'assistant_error',
-                        error: String(err?.stack ?? err).slice(0, 2000),
-                    }));
-                doc.items.push({ kind: 'error', text: shown.message, code: shown.code });
-                emit('error', shown);
-            }
-        }
-        finally {
-            await tools.close();
-        }
-        doc.usage = spent();
-        await this.writeChat(caller, chatId, doc).catch(() => undefined);
-        await this.state
-            .addSpend(caller.id, paying.payer, live.map((m) => m.part()))
-            .catch(() => undefined);
-        if (outcome !== 'stopped')
-            emit('done', { id: chatId, usage: doc.usage });
-        const total = live.reduce((a, m) => ({
-            calls: a.calls + m.calls,
-            in: a.in + m.in,
-            out: a.out + m.out,
-            usd: a.usd + m.usd,
-        }), { calls: 0, in: 0, out: 0, usd: 0 });
-        await Promise.resolve(this.o.onStep?.({
-            kind: 'turn',
-            outcome,
-            ms: Math.round(performance.now() - t0),
-            tier: main.tier.id,
-            end_tier: counts.end.id,
-            handoffs: counts.handoffs,
-            advice: counts.advice,
-            steps: counts.steps,
-            ...total,
-        })).catch(() => undefined);
-    }
     /** What the kit adds to the app's instructions: tools, drafts, hand off, advice, limits. */
     rules(main, policy, advisor, fns, failed) {
         const lines = [
@@ -1280,27 +789,6 @@ export class Assistant {
         session.meter = new Meter(session.model, `${session.tier.label} · advice`);
         return { session, asked: 0 };
     }
-    escalateTool(main) {
-        const reach = this.above(main);
-        if (!reach.length)
-            return null;
-        return {
-            name: 'escalate',
-            description: 'Hands one task to a higher tier with the same tools. It works in its own section and returns a memo of at most 200 words.',
-            input_schema: {
-                type: 'object',
-                properties: {
-                    tier: { type: 'string', enum: reach.map((t) => t.id) },
-                    why: { type: 'string', enum: [...HAND_OFF_WHYS] },
-                    task: {
-                        type: 'string',
-                        description: 'The task, with every fact from the chat it needs.',
-                    },
-                },
-                required: ['tier', 'why', 'task'],
-            },
-        };
-    }
     /** 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);
@@ -1323,654 +811,6 @@ export class Assistant {
             asked.add(reach[0].id);
         return asked;
     }
-    async handOff(use, c) {
-        const reply = (content, is_error = false) => ({
-            type: 'tool_result',
-            tool_use_id: use.id,
-            content,
-            is_error,
-        });
-        const input = (use.input ?? {});
-        const reach = this.above(c.main.tier);
-        const tier = reach.find((t) => t.id === input.tier);
-        const why = HAND_OFF_WHYS.find((w) => w === input.why);
-        const task = typeof input.task === 'string' ? input.task.trim() : '';
-        if (!tier || !why || !task)
-            return reply(`Give {tier: ${reach.map((t) => `"${t.id}"`).join(' | ')}, why: ${HAND_OFF_WHYS.map((w) => `"${w}"`).join(' | ')}, task}.`, true);
-        const asked = this.askedFor(c.message, c.main.tier);
-        if (c.handTo)
-            asked.add(c.handTo.id);
-        const own = c.policy === 'any' ? reach : c.policy === 'next' ? reach.slice(0, 1) : [];
-        const may = new Set([...own.map((t) => t.id), ...asked]);
-        if (!may.has(tier.id))
-            return reply(may.size
-                ? `Not ${tier.id} now: you may call ${[...may].join(' or ')}.`
-                : 'The person has not asked for a higher tier: answer yourself.', true);
-        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))
-            c.counts.end = tier;
-        const item = {
-            kind: 'handoff',
-            tier: tier.id,
-            label: sub.meter.label,
-            task: task.replace(/\s+/g, ' ').slice(0, 200),
-            why: asked.has(tier.id) ? 'asked' : why,
-            items: [],
-        };
-        c.sink.push(item);
-        c.emit('handoff', {
-            kind: 'handoff',
-            tier: item.tier,
-            label: item.label,
-            task: item.task,
-            why: item.why,
-        });
-        const inside = (event, data) => c.emit(event, { ...data, handoff: true });
-        let memo = '';
-        let failed;
-        try {
-            memo = await this.loop({
-                clients: c.clients,
-                session: sub,
-                system: c.system,
-                tools: this.toolsFor(c.tools),
-                messages: [
-                    {
-                        role: 'user',
-                        content: `${c.page}The person asked: ${c.message}\n\n${this.name} handed you this task (${WHY_TEXT[item.why]}): ${task}\n\nWork it out with the tools, then end with a memo for ${this.name} of at most 200 words: the answer and the facts it rests on. ${this.name} answers the person.`,
-                    },
-                ],
-                sink: item.items,
-                emit: inside,
-                signal: c.signal,
-                over: c.over,
-                called: () => c.emit('usage', c.spent()),
-                tool: (u) => this.runTool(u, c.tools, item.items, inside, c.runs, c.counts, sub, true, c.signal),
-            });
-        }
-        catch (err) {
-            if (c.signal?.aborted)
-                throw err;
-            const shown = shownError(err);
-            failed = shown.message;
-            item.items.push({ kind: 'error', text: failed, code: shown.code });
-            inside('error', shown);
-        }
-        finally {
-            item.usage = sub.meter.part();
-            c.emit('handoff_done', { usage: item.usage });
-        }
-        return failed
-            ? reply(`${item.label} failed: ${failed}`, true)
-            : reply(`Memo from ${item.label}:\n${memo.slice(0, MEMO_CHARS)}`);
-    }
-    /** One tool call: a draft card for a write, else the call itself, timed. */
-    async runTool(use, fns, sink, emit, runs, counts, session, handoff, signal, 
-    /** Part of a batch: runs and is remembered, but draws no step of its own. */
-    quiet = false) {
-        const reply = (content, is_error = false) => ({
-            type: 'tool_result',
-            tool_use_id: use.id,
-            content,
-            is_error,
-        });
-        if (use.name === BATCH && !fns.has(BATCH) && !quiet)
-            return this.runBatch(use, fns, sink, emit, runs, counts, session, handoff, signal);
-        const f = fns.get(use.name);
-        if (!f)
-            return reply(`No tool ${use.name}.`, true);
-        const title = f.def.title ?? f.def.name;
-        if (f.draft) {
-            const item = {
-                kind: 'draft',
-                id: newId('d'),
-                tool: use.name,
-                title,
-                args: use.input,
-                status: 'open',
-            };
-            sink.push(item);
-            emit('draft', item);
-            await Promise.resolve(this.o.onStep?.({ kind: 'draft', tool: use.name, tier: session.tier.id, handoff })).catch(() => undefined);
-            return reply(`Drafted: a "${title}" card is on the person's screen. Nothing changed until they press Save.`);
-        }
-        // The same read with the same input in one answer gives back what it gave, without running it
-        // again or showing a second step: a model that lost track of a result reads it here, not twice.
-        const key = f.write ? '' : `${use.name}\u0000${stableJson(use.input)}`;
-        const again = key ? counts.seen.get(key) : undefined;
-        if (again)
-            return reply(`(Same call as earlier in this answer; its result again.)\n${await again}`);
-        let settle = () => undefined;
-        if (key)
-            counts.seen.set(key, new Promise((done) => {
-                settle = done;
-            }));
-        const id = newId('s');
-        if (!quiet)
-            emit('step_start', { id, tool: use.name, title });
-        const t0 = performance.now();
-        let out;
-        let ok = true;
-        let error;
-        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);
-        }
-        catch (err) {
-            if (signal?.aborted) {
-                settle('(stopped)');
-                throw err;
-            }
-            ok = false;
-            error =
-                err instanceof ToolError || err instanceof Error ? err.message.slice(0, 300) : 'failed';
-            out = error;
-        }
-        const ms = Math.round(performance.now() - t0);
-        const item = {
-            kind: 'step',
-            id,
-            tool: use.name,
-            title,
-            ok,
-            ms,
-            ...(rows !== undefined ? { rows } : {}),
-            ...(error ? { error } : {}),
-            ...(f.write && ok
-                ? { write: { undo: !!this.groupById(f.group)?.undo, status: 'done' } }
-                : {}),
-        };
-        if (!quiet) {
-            sink.push(item);
-            emit('step', item);
-            counts.steps += 1;
-        }
-        // A change made at once can make an earlier read stale: reads after it run again.
-        if (f.write)
-            counts.seen.clear();
-        runs.push({ tool: use.name, key, result: out });
-        await Promise.resolve(this.o.onStep?.({
-            kind: 'tool',
-            tool: use.name,
-            ok,
-            ms,
-            ...(rows !== undefined ? { rows } : {}),
-            ...(error ? { error } : {}),
-            tier: session.tier.id,
-            handoff,
-        })).catch(() => undefined);
-        const cut = out.length > RESULT_CHARS
-            ? `${out.slice(0, RESULT_CHARS)} …(cut at ${RESULT_CHARS.toLocaleString('en-US')} of ${out.length.toLocaleString('en-US')} characters: the rest was not read; ask again for less)`
-            : out;
-        if (key) {
-            settle(cut);
-            if (!ok)
-                counts.seen.delete(key);
-        }
-        return reply(cut, !ok);
-    }
-    /** A batch of reads: each runs as its own call (the same read twice runs once), in parallel, shown as one step. */
-    async runBatch(use, fns, sink, emit, runs, counts, session, handoff, signal) {
-        const reply = (content, is_error = false) => ({
-            type: 'tool_result',
-            tool_use_id: use.id,
-            content,
-            is_error,
-        });
-        const raw = use.input?.calls;
-        const calls = (Array.isArray(raw) ? raw : []).map((c) => {
-            const o = (c && typeof c === 'object' ? c : {});
-            return {
-                tool: typeof o.tool === 'string' ? o.tool : '',
-                input: o.input && typeof o.input === 'object' ? o.input : {},
-            };
-        });
-        if (!calls.length)
-            return reply(`Give {calls: [{tool, input}]}: 1 to ${BATCH_MAX} reads.`, true);
-        if (calls.length > BATCH_MAX)
-            return reply(`At most ${BATCH_MAX} calls a batch: split them into batches.`, true);
-        const titles = [...new Set(calls.map((c) => fns.get(c.tool)?.def.title ?? c.tool))];
-        const title = titles.length === 1 ? `${titles[0]} ×${calls.length}` : `${calls.length} reads`;
-        const id = newId('s');
-        emit('step_start', { id, tool: BATCH, title });
-        const t0 = performance.now();
-        const done = await Promise.all(calls.map(async (c, i) => {
-            const f = fns.get(c.tool);
-            if (!f)
-                return { ...c, ok: false, text: `No tool ${c.tool}.` };
-            if (f.draft || f.write)
-                return { ...c, ok: false, text: 'Only reads go in a batch: call this tool on its own.' };
-            const r = await this.runTool({
-                type: 'tool_use',
-                id: `${use.id}_${i}`,
-                name: c.tool,
-                input: c.input,
-            }, fns, sink, emit, runs, counts, session, handoff, signal, true);
-            return { ...c, ok: !r.is_error, text: typeof r.content === 'string' ? r.content : '' };
-        }));
-        const failed = done.filter((d) => !d.ok).length;
-        const item = {
-            kind: 'step',
-            id,
-            tool: BATCH,
-            title,
-            ok: failed < done.length,
-            ms: Math.round(performance.now() - t0),
-            ...(failed ? { error: `${failed} of ${done.length} failed` } : {}),
-        };
-        sink.push(item);
-        emit('step', item);
-        counts.steps += 1;
-        let left = BATCH_CHARS;
-        const parts = done.map((d, i) => {
-            const fits = d.text.length <= left;
-            left -= fits ? d.text.length : 0;
-            return `[${i + 1}] ${d.tool} ${stableJson(d.input)}${d.ok ? '' : ' (failed)'}\n${fits
-                ? d.text
-                : '(left out: the batch passed its size; read this one again in a smaller batch)'}`;
-        });
-        return reply(parts.join('\n\n'), failed === done.length);
-    }
-    /** Model calls and tool rounds until the model answers; returns its words. */
-    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.
-        // An earlier answer that said nothing (only a cut mark) is left out: an empty turn is refused.
-        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'),
-        }))
-            .filter((m) => m.role !== 'assistant' || m.content.replace('…(cut)', '').trim() !== '');
-        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
-        // (`max_output_tokens` is unsupported there: developers.openai.com/siwc, Preview limitations).
-        const sent = (only) => {
-            const fns = only ? fnTools.filter((t) => t.name === only) : fnTools;
-            const out = plan ? {} : { max_output_tokens: session.tier.out ?? DEFAULT_OUT };
-            if (!plan)
-                return { tools: fns, ...out };
-            return {
-                ...out,
-                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;
-            // The raw event stream, not the SDK's accumulator: a plan sign-in's backend sends event types
-            // the SDK does not know and its accumulator throws on them. The final response rides on the
-            // completed, incomplete or failed event; every other event but text deltas is skipped.
-            let partial = '';
-            // Event types seen and the items finished one by one: a plan sign-in's final event may carry
-            // an empty `output`, its items having come only as `response.output_item.done`.
-            let seen = {};
-            let items = [];
-            // An error OpenAI sends inside the stream: logged in full, shown as a plain sentence.
-            const streamFailure = (er) => {
-                if (partial)
-                    sink.push({ kind: 'text', text: partial });
-                console.error(JSON.stringify({
-                    event: 'assistant_openai_error',
-                    model: session.model.id,
-                    plan,
-                    code: er.code ?? null,
-                    type: er.type ?? null,
-                    param: er.param ?? null,
-                    message: er.message?.slice(0, 500) ?? null,
-                    events: seen,
-                }));
-                return new AssistantError(openaiStreamError(er.code || er.type || '', plan), 'upstream');
-            };
-            // One call of this round; asked again (fresh stream state) when it spends its whole output
-            // on reasoning.
-            const ask = (eff) => {
-                partial = '';
-                seen = {};
-                items = [];
-                return askOnce(eff);
-            };
-            const askOnce = (eff) => (async () => {
-                const stream = await client.responses.create({
-                    model: session.model.id,
-                    instructions,
-                    input,
-                    ...sent(only),
-                    store: false,
-                    stream: true,
-                    include: ['reasoning.encrypted_content'],
-                    ...(eff ? { reasoning: { effort: eff } } : {}),
-                    ...(choice ? { tool_choice: choice } : {}),
-                }, signal ? { signal } : {});
-                let done;
-                for await (const e of stream) {
-                    seen[e.type] = (seen[e.type] ?? 0) + 1;
-                    if (e.type === 'response.output_item.done' && e.item)
-                        items.push(e.item);
-                    if (e.type === 'response.output_text.delta' && typeof e.delta === 'string') {
-                        partial += e.delta;
-                        emit('text', { delta: e.delta });
-                    }
-                    else if (e.type === 'response.completed' ||
-                        e.type === 'response.incomplete' ||
-                        e.type === 'response.failed') {
-                        done = e.response;
-                    }
-                    else if (e.type === 'error') {
-                        const er = (e.error ?? e);
-                        throw streamFailure(er);
-                    }
-                }
-                if (!done)
-                    throw new AssistantError('OpenAI ended the answer early.', 'upstream');
-                return done;
-            })().catch((err) => {
-                if (signal?.aborted && partial)
-                    sink.push({ kind: 'text', text: partial });
-                // The SDK throws a stream's `error` event as an APIError with no HTTP status.
-                if (err instanceof OpenAI.APIError && err.status === undefined) {
-                    const er = (err.error ?? {});
-                    throw streamFailure({
-                        ...er,
-                        code: er.code ?? err.code ?? undefined,
-                        message: er.message ?? err.message,
-                    });
-                }
-                throw err;
-            });
-            let res = await ask(effort);
-            // A reasoning model can spend the whole output on thinking and say nothing: ask once more
-            // with less thinking before giving up. One that stopped before writing anything is not asked
-            // again: less thinking cannot help it.
-            if (res.status === 'incomplete' &&
-                res.incomplete_details?.reason === 'max_output_tokens' &&
-                (res.usage?.output_tokens ?? 0) > 0 &&
-                !partial &&
-                !shows(res.output?.length ? res.output : items) &&
-                effort !== 'low') {
-                console.error(JSON.stringify({
-                    event: 'assistant_openai_retry',
-                    model: session.model.id,
-                    plan,
-                    why: 'no_words',
-                    usage: res.usage ?? null,
-                    events: seen,
-                }));
-                res = await ask('low');
-            }
-            if (res.status === 'failed') {
-                if (partial)
-                    sink.push({ kind: 'text', text: partial });
-                const code = res.error?.code ?? '';
-                console.error(JSON.stringify({
-                    event: 'assistant_openai_failed',
-                    model: session.model.id,
-                    plan,
-                    code,
-                    message: res.error?.message?.slice(0, 300) ?? null,
-                    events: seen,
-                }));
-                throw new AssistantError(openaiStreamError(code, plan), '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 output = (res.output?.length ? res.output : items);
-            res.output = output;
-            // Raw events carry no `output_text`: the words are the output messages' text parts.
-            const words = output
-                .flatMap((b) => (b.type === 'message' ? b.content : []))
-                .map((c) => (c.type === 'output_text' ? c.text : ''))
-                .join('') || partial;
-            const hasCall = output.some((b) => b.type === 'function_call');
-            if (!words && !hasCall) {
-                // Nothing to show: say why instead of an empty or bare "cut" answer, and log the shape.
-                console.error(JSON.stringify({
-                    event: 'assistant_openai_empty',
-                    model: session.model.id,
-                    plan,
-                    status: res.status,
-                    incomplete: res.incomplete_details ?? null,
-                    usage: res.usage ?? null,
-                    events: seen,
-                    output: output.map((b) => b.type),
-                    parts: output.flatMap((b) => b.type === 'message' ? b.content.map((c) => c.type) : []),
-                }));
-                if (!answer)
-                    throw new AssistantError(res.incomplete_details?.reason === 'max_output_tokens' && !res.usage?.output_tokens
-                        ? 'OpenAI stopped before reading the message. Try again, or pick another model for this tier.'
-                        : res.incomplete_details?.reason === 'max_output_tokens'
-                            ? 'OpenAI spent the whole answer thinking and wrote nothing. Try again, or pick a smaller tier.'
-                            : res.incomplete_details?.reason
-                                ? `OpenAI stopped before answering (${res.incomplete_details.reason}).`
-                                : 'OpenAI sent no answer.', 'upstream');
-            }
-            const cut = res.incomplete_details?.reason === 'max_output_tokens' && (words || hasCall)
-                ? ' …(cut)'
-                : '';
-            if (cut)
-                emit('text', { delta: cut });
-            const text = words + 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(...output);
-            const calls = 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;
-        for (let round = 0; round < MAX_ROUNDS; round++) {
-            signal?.throwIfAborted();
-            // The system prompt and tools are one cached prefix; the chat so far a second breakpoint.
-            const sent = messages.map((m, i) => (i === messages.length - 1 ? withCacheMark(m) : m));
-            const params = {
-                model: session.model.id,
-                max_tokens: session.tier.out ?? DEFAULT_OUT,
-                ...effortParams(session.effort),
-                system,
-                tools,
-                messages: sent,
-                ...(force ? { tool_choice: force } : {}),
-            };
-            const adv = o.advisor;
-            // A forced tool choice may not come with the advisor; the beta header stays while it is on.
-            const advise = adv && adv.asked < ADVICE_MAX && force?.type !== 'tool' && force?.type !== 'any';
-            const stream = adv
-                ? client.beta.messages.stream({
-                    ...params,
-                    tools: [
-                        ...tools,
-                        ...(advise
-                            ? [
-                                {
-                                    type: 'advisor_20260301',
-                                    name: 'advisor',
-                                    model: adv.session.model.id,
-                                    max_tokens: ADVICE_TOKENS,
-                                    caching: { type: 'ephemeral', ttl: '5m' },
-                                },
-                            ]
-                            : []),
-                    ],
-                    betas: [ADVISOR_BETA],
-                }, { signal })
-                : client.messages.stream(params, signal ? { signal } : {});
-            let partial = '';
-            stream.on('text', (delta) => {
-                partial += delta;
-                emit('text', { delta });
-            });
-            if (adv)
-                stream.on('streamEvent', (e) => {
-                    if (e.type !== 'content_block_start')
-                        return;
-                    const b = e.content_block;
-                    const label = adv.session.meter.label;
-                    if (b.type === 'server_tool_use' && b.name === 'advisor') {
-                        adv.asked += 1;
-                        emit('advice', { tier: adv.session.tier.id, label });
-                    }
-                    else if (b.type === 'advisor_tool_result') {
-                        const error = b.content?.type === 'advisor_tool_result_error'
-                            ? (b.content.error_code ?? 'error')
-                            : undefined;
-                        sink.push({
-                            kind: 'advice',
-                            tier: adv.session.tier.id,
-                            label,
-                            ...(error ? { error } : {}),
-                        });
-                        emit('advice_done', error ? { error } : {});
-                    }
-                });
-            const msg = await stream.finalMessage().catch((err) => {
-                if (signal?.aborted && partial)
-                    sink.push({ kind: 'text', text: partial });
-                throw err;
-            });
-            session.meter.add(msg.usage);
-            if (adv)
-                for (const it of msg.usage.iterations ?? [])
-                    if (it.type === 'advisor_message')
-                        adv.session.meter.add(it);
-            o.context?.(msg.usage.input_tokens +
-                (msg.usage.cache_read_input_tokens ?? 0) +
-                (msg.usage.cache_creation_input_tokens ?? 0) +
-                msg.usage.output_tokens);
-            o.called();
-            const cut = msg.stop_reason === 'max_tokens' ? ' …(cut)' : '';
-            if (cut)
-                emit('text', { delta: cut });
-            const text = msg.content
-                .filter((b) => b.type === 'text')
-                .map((b) => b.text)
-                .join('') + cut;
-            if (text) {
-                answer += (answer ? '\n\n' : '') + text;
-                sink.push({ kind: 'text', text });
-                emit('text_end', {});
-            }
-            messages.push({ role: 'assistant', content: msg.content });
-            if (msg.stop_reason === 'pause_turn')
-                continue;
-            const uses = msg.content.filter((b) => b.type === 'tool_use');
-            if (msg.stop_reason !== 'tool_use' || uses.length === 0)
-                break;
-            const results = await Promise.all(uses.map((use) => untilStopped(o.tool(use), signal)));
-            if (force === o.first)
-                force = undefined;
-            const limit = o.over();
-            if (limit) {
-                results.push({ type: 'text', text: limit });
-                force = { type: 'none' };
-            }
-            else if (round === MAX_ROUNDS - 2) {
-                results.push({ type: 'text', text: 'No more tool calls: answer now from what you have.' });
-                force = { type: 'none' };
-            }
-            messages.push({ role: 'user', content: results });
-        }
-        return answer;
-    }
     /** Swaps the history for a short summary. False with nothing to compact. */
     /**
      * One plain answer from OpenAI, metered on `s`: no tools, no chat. Streamed and read from the raw
@@ -2040,40 +880,6 @@ export class Assistant {
         }
         return text || done?.output_text || '';
     }
-    async compact(clients, s, doc, emit) {
-        if (doc.history.length < 2)
-            return false;
-        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 = toolMemory(doc.history)
-            .map((t) => `${t.role === 'user' ? 'Person' : this.name}: ${t.content}`)
-            .join('\n\n');
-        let summary = '';
-        if (s.model.provider === 'openai' && clients.openai) {
-            summary = await this.openaiOnce(clients, s, system, chat, 1500);
-        }
-        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.' },
-        ];
-        doc.items.push({ kind: 'compacted' });
-        emit('compacted', {});
-        return true;
-    }
     // ---------------------------------------------------------------- one-shot work
     /**
      * One prompt answered on a task's tier as the person: no chat, no tools. It is for background
@@ -2139,23 +945,6 @@ export class Assistant {
         }
         return { text, usd: s.meter.usd, model: s.model.id };
     }
-    /** How the person's cards ended since the last answer, once each. */
-    cardNews(doc) {
-        const told = new Set(doc.told ?? []);
-        const news = draftsOf(doc.items).filter((d) => d.status !== 'open' && !told.has(d.id));
-        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), ...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`;
-    }
     // ---------------------------------------------------------------- keys
     /** Starts a person's ChatGPT plan sign-in: the address to open in a new tab. */
     async startSignin(caller, provider) {
@@ -2268,70 +1057,6 @@ export class Assistant {
             };
         }
     }
-    // ---------------------------------------------------------------- drafts
-    /** Saves (runs, as the person) or dismisses a drafted card. Access is checked again first. */
-    async settleDraft(caller, chatId, draftId, action) {
-        const doc = await this.state.docs.read(caller.id, `chat:${chatId}`);
-        if (!doc)
-            throw new AssistantError('That chat is gone.', 'not_found', 404);
-        const d = draftsOf(doc.items).find((x) => x.id === draftId);
-        if (!d)
-            throw new AssistantError('That card is gone.', 'not_found', 404);
-        if (d.status !== 'open')
-            throw new AssistantError(`That card is already ${d.status}.`, 'settled', 409);
-        if (action === 'dismiss')
-            d.status = 'dismissed';
-        else {
-            const p = await this.state.person(caller.id);
-            const tools = await this.openTools(caller, p);
-            try {
-                const f = tools.fns.get(d.tool);
-                if (!f || f.def.read) {
-                    d.status = 'failed';
-                    d.error = 'Its tools are no longer on Read + draft or Read + write in Settings ▸ Tools.';
-                }
-                else {
-                    try {
-                        d.result = await withDeadline(d.title, 60_000, f.open.call(f.def.name, d.args));
-                        d.status = 'saved';
-                    }
-                    catch (err) {
-                        d.status = 'failed';
-                        d.error = err instanceof Error ? err.message.slice(0, 300) : 'failed';
-                    }
-                }
-            }
-            finally {
-                await tools.close();
-            }
-        }
-        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);