@columenlabs/lumen-ai 0.1.138 → 0.1.139

package/dist/assistant/engine.d.ts

@@ -239,8 +239,6 @@ export declare class Assistant {
     private compact;
     /** How the person's cards ended since the last answer, once each. */
     private cardNews;
-    /** The answer as later turns remember it: with what its tools returned, cut. */
-    private remember;
     /** Starts a person's ChatGPT plan sign-in: the address to open in a new tab. */
     startSignin(caller: Caller, provider: AssistantProvider): Promise<{
         url: string;

package/dist/assistant/engine.js

@@ -48,9 +48,16 @@ const MEMO_CHARS = 8000;
 const ADVICE_MAX = 2;
 const ADVICE_TOKENS = 2048;
 const ADVISOR_BETA = 'advisor-tool-2026-03-01';
-/** What later turns remember of a turn's tool results. */
-const RAN_CHARS = 1500;
-const RAN_TOTAL = 6000;
+/**
+ * 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',
@@ -58,6 +65,58 @@ 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 })) };
@@ -684,7 +743,14 @@ export class Assistant {
         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 };
+        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);
@@ -738,7 +804,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`
                 : '';
             const messages = [
-                ...doc.history.map((t) => ({ role: t.role, content: t.content })),
+                ...toolMemory(doc.history),
                 { role: 'user', content: `${page}${lead}${asked}` },
             ];
             const escalateTool = this.escalateTool(main.tier);
@@ -791,7 +857,7 @@ export class Assistant {
                 emit('text_end', {});
             }
             doc.history.push({ role: 'user', content: `${page}${asked}` });
-            doc.history.push({ role: 'assistant', content: this.remember(answer, runs) });
+            doc.history.push({ role: 'assistant', content: answer, ...ranOf(runs) });
         }
         catch (err) {
             if (signal?.aborted) {
@@ -1045,6 +1111,17 @@ export class Assistant {
             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');
         emit('step_start', { id, tool: use.name, title });
         const t0 = performance.now();
@@ -1060,8 +1137,10 @@ export class Assistant {
             out = typeof result === 'string' ? result : JSON.stringify(result);
         }
         catch (err) {
-            if (signal?.aborted)
+            if (signal?.aborted) {
+                settle('(stopped)');
                 throw err;
+            }
             ok = false;
             error =
                 err instanceof ToolError || err instanceof Error ? err.message.slice(0, 300) : 'failed';
@@ -1084,7 +1163,10 @@ export class Assistant {
         sink.push(item);
         emit('step', item);
         counts.steps += 1;
-        runs.push({ tool: use.name, result: out.slice(0, RAN_CHARS) });
+        // 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,
@@ -1095,7 +1177,14 @@ export class Assistant {
             tier: session.tier.id,
             handoff,
         })).catch(() => undefined);
-        const cut = out.length > RESULT_CHARS ? `${out.slice(0, RESULT_CHARS)} …(cut: ask for less)` : out;
+        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);
     }
     /** Model calls and tool rounds until the model answers; returns its words. */
@@ -1493,7 +1582,7 @@ export class Assistant {
         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 = doc.history
+        const chat = toolMemory(doc.history)
             .map((t) => `${t.role === 'user' ? 'Person' : this.name}: ${t.content}`)
             .join('\n\n');
         let summary = '';
@@ -1554,21 +1643,6 @@ export class Assistant {
             .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`;
     }
-    /** The answer as later turns remember it: with what its tools returned, cut. */
-    remember(answer, runs) {
-        if (!runs.length)
-            return answer;
-        let left = RAN_TOTAL;
-        const lines = [];
-        for (const r of runs) {
-            if (left <= 0)
-                break;
-            const line = `- ${r.tool} → ${r.result.slice(0, Math.min(RAN_CHARS, left))}`;
-            left -= line.length;
-            lines.push(line);
-        }
-        return `${answer}\n\n[Tools I used and what they returned]\n${lines.join('\n')}`;
-    }
     // ---------------------------------------------------------------- keys
     /** Starts a person's ChatGPT plan sign-in: the address to open in a new tab. */
     async startSignin(caller, provider) {

package/dist/assistant/tools.d.ts

@@ -45,5 +45,5 @@ export interface PlainTool extends ToolDef {
 export declare function plainTools(tools: PlainTool[]): ToolSource;
 /** A tool name the model may use: letters, digits, `_` and `-`, at most 64. */
 export declare function toolName(group: string, name: string): string;
-/** Rows in a list result: an array, or the first array field of an object. */
+/** Rows in a list result: an array, an object's `count`, or the one array an object holds. */
 export declare function rowCount(v: unknown): number | undefined;

package/dist/assistant/tools.js

@@ -98,13 +98,17 @@ export function plainTools(tools) {
 export function toolName(group, name) {
     return `${group}__${name}`.replace(/[^a-zA-Z0-9_-]/g, '_').slice(0, 64);
 }
-/** Rows in a list result: an array, or the first array field of an object. */
+/** Rows in a list result: an array, an object's `count`, or the one array an object holds. */
 export function rowCount(v) {
     if (Array.isArray(v))
         return v.length;
-    if (v && typeof v === 'object')
-        for (const x of Object.values(v))
-            if (Array.isArray(x))
-                return x.length;
-    return undefined;
+    if (!v || typeof v !== 'object')
+        return undefined;
+    // A list with its total says so; else the one list it holds. A record with several lists (a
+    // recipe's ingredients and steps) is one thing, not rows.
+    const o = v;
+    if (typeof o.count === 'number' && Number.isFinite(o.count))
+        return o.count;
+    const lists = Object.values(o).filter(Array.isArray);
+    return lists.length === 1 ? lists[0]?.length : undefined;
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@columenlabs/lumen-ai",
-  "version": "0.1.138",
+  "version": "0.1.139",
   "description": "Lumen's assistant and agent parts: a chat assistant's server (Claude tiers, tools over MCP, the web, hand off, spend caps), serving an MCP server from a Worker, read-only tool sets and metered tool calls.",
   "license": "MIT",
   "type": "module",
@@ -41,8 +41,8 @@
   },
   "dependencies": {
     "@anthropic-ai/sdk": "0.133.0",
-    "@columenlabs/lumen-ops": "0.1.138",
-    "@columenlabs/lumen-ui-types": "0.1.138",
+    "@columenlabs/lumen-ops": "0.1.139",
+    "@columenlabs/lumen-ui-types": "0.1.139",
     "openai": "7.32.0",
     "zod": "^4.3.6"
   },