@columenlabs/lumen-ai 0.1.265 → 0.1.266

package/README.md

@@ -162,7 +162,7 @@ The panel's composer lists what can follow three keys as they are typed. The kit
 
 ### Bearings
 
-Each message the model gets starts with a few lines of bearings: the time now in the person's zone (the panel sends the browser's), UTC, how long since the chat's last message and the app's name. They go in the message, not the system prompt, so the prompt cache holds. Each turn's lead (bearings, `plan.lead`, news) is kept with the message it came before and sent again on later turns, so every turn's prompt starts with the last turn's whole prompt and the cache reads it; a chat's OpenAI calls carry the chat's id as their cache key. An app adds its own lines with `bearings`; each call gets 300 ms, and when it is late or throws its lines are left out.
+Each message the model gets starts with a few lines of bearings: the time now in the person's zone (the panel sends the browser's), UTC, how long since the chat's last message and the app's name. They go in the message, not the system prompt, so the prompt cache holds. A turn's lead (bearings, `plan.lead`, news) goes before the newest message only, so the chat never grows by it; a chat's OpenAI calls carry the chat's id as their cache key. `/compact` in the panel summarizes the chat's older part at once (as past `compactAt()`), without asking the model. An app adds its own lines with `bearings`; each call gets 300 ms, and when it is late or throws its lines are left out.
 
 ```ts
 createAssistant({

package/dist/agent/agent.d.ts

@@ -123,28 +123,10 @@ export interface AgentCard {
 export declare const COMPACT_AT = 150000;
 /** What the model is told of cards settled and changes undone since its last answer. */
 export declare function cardNews(cards: AgentCard[]): string;
+/** The panel's command that compacts the chat now (the kit's slash command). */
+export declare const COMPACT_COMMAND = "/compact";
 /** The messages with `lead` put before the newest message the person wrote. */
 export declare function withLead(messages: ModelMessage[], lead: string | undefined): ModelMessage[];
-/** A lead a past turn put before one of the person's messages, kept so later turns send it again. */
-export interface KeptLead {
-    /** The message's place among the person's messages and a hash of what it says. */
-    k: string;
-    lead: string;
-}
-/** Leads kept for the newest messages; older ones fall out of the chat's prompt cache anyway. */
-export declare const LEADS_KEPT = 40;
-/**
- * The messages with this turn's `lead` before the newest message the person wrote, and every lead
- * an earlier turn put before an earlier message put back where it was. A lead that is sent once
- * and then dropped changes the chat's beginning on the next turn, so the provider's prompt cache
- * misses from that message on and the whole earlier turn (its tool calls and results) is paid for
- * again at the full price. Sent again, every turn's prompt starts with the last turn's prompt.
- * Returns the leads to keep (this one included), newest last.
- */
-export declare function withLeads(messages: ModelMessage[], lead: string | undefined, kept: readonly KeptLead[]): {
-    messages: ModelMessage[];
-    kept: KeptLead[];
-};
 /** One message the person sent, with the page, refs and tier the composer added. */
 export interface AskInput {
     message: string;

package/dist/agent/agent.js

@@ -58,6 +58,8 @@ const cardOf = (r) => ({
     ...(r.error ? { error: r.error } : {}),
     at: r.at,
 });
+/** The panel's command that compacts the chat now (the kit's slash command). */
+export const COMPACT_COMMAND = '/compact';
 /** The messages with `lead` put before the newest message the person wrote. */
 export function withLead(messages, lead) {
     if (!lead)
@@ -77,50 +79,6 @@ function leadAt(messages, i, lead) {
         : [{ type: 'text', text: lead }, ...m.content];
     return [...messages.slice(0, i), { ...m, content }, ...messages.slice(i + 1)];
 }
-/** Leads kept for the newest messages; older ones fall out of the chat's prompt cache anyway. */
-export const LEADS_KEPT = 40;
-/** A short, stable hash of a message's content (FNV-1a), to know the same message again. */
-function contentKey(n, m) {
-    const text = typeof m.content === 'string' ? m.content : JSON.stringify(m.content);
-    let h = 0x811c9dc5;
-    for (let i = 0; i < text.length; i++) {
-        h ^= text.charCodeAt(i);
-        h = Math.imul(h, 0x01000193);
-    }
-    return `${n}:${(h >>> 0).toString(36)}:${text.length}`;
-}
-/**
- * The messages with this turn's `lead` before the newest message the person wrote, and every lead
- * an earlier turn put before an earlier message put back where it was. A lead that is sent once
- * and then dropped changes the chat's beginning on the next turn, so the provider's prompt cache
- * misses from that message on and the whole earlier turn (its tool calls and results) is paid for
- * again at the full price. Sent again, every turn's prompt starts with the last turn's prompt.
- * Returns the leads to keep (this one included), newest last.
- */
-export function withLeads(messages, lead, kept) {
-    const users = [];
-    messages.forEach((m, i) => {
-        if (m.role === 'user')
-            users.push(i);
-    });
-    const newest = users.at(-1);
-    const byKey = new Map(kept.map((l) => [l.k, l.lead]));
-    let out = messages;
-    users.forEach((at, n) => {
-        if (at === newest)
-            return;
-        const l = byKey.get(contentKey(n, messages[at]));
-        if (l)
-            out = leadAt(out, at, l);
-    });
-    if (newest === undefined || !lead)
-        return { messages: out, kept: [...kept] };
-    const k = contentKey(users.length - 1, messages[newest]);
-    return {
-        messages: leadAt(out, newest, lead),
-        kept: [...kept.filter((l) => l.k !== k), { k, lead }].slice(-LEADS_KEPT),
-    };
-}
 /** A quote as sent, checked: its text cut to `ASSISTANT_QUOTE_MAX`, and whose message it came from. */
 export function quoteOf(q) {
     const o = q;
@@ -356,6 +314,11 @@ export class LumenAgent extends Think {
         }
         this.#put('at', at);
         await sink.event({ event: 'chat', data: { id: this.name, title } });
+        if (input.message.trim() === COMPACT_COMMAND) {
+            await this.#compactNow(input, sink);
+            await sink.event({ event: 'done', data: { id: this.name, usage: this.usage() } });
+            return;
+        }
         // New work in a long chat: the panel asks first, and the message is not kept or answered here.
         if (!input.stay && (await this.offerFresh(input).catch(() => false))) {
             await sink.event({ event: 'fresh', data: {} });
@@ -629,6 +592,39 @@ export class LumenAgent extends Think {
             .onCompaction(createCompactFunction({ summarize: (prompt) => this.#summarize(prompt) }))
             .compactAfter(this.compactAt());
     }
+    /**
+     * /compact: the chat's older part summarized now, as Think does past `compactAt()`, on the last
+     * turn's model and key (planned afresh when this object has not answered yet). Never a message
+     * to the model, and nothing to answer.
+     */
+    async #compactNow(input, sink) {
+        try {
+            if (!this.#last) {
+                this.#input = { ...input, message: '' };
+                try {
+                    this.#last = { plan: await this.plan({ messages: [] }) };
+                }
+                finally {
+                    this.#input = null;
+                }
+            }
+            const r = await this.session.compact();
+            if (r)
+                await sink.event({ event: 'compacted', data: {} });
+            else
+                await sink.event({
+                    event: 'text',
+                    data: { delta: 'This chat is already short: nothing to compact yet.' },
+                });
+        }
+        catch (err) {
+            console.error(JSON.stringify({ event: 'assistant_compact_failed', error: String(err) }));
+            await sink.event({
+                event: 'error',
+                data: { message: 'The chat could not be compacted. Try again, or start a new chat.' },
+            });
+        }
+    }
     async #summarize(prompt) {
         const last = this.#last;
         if (!last)
@@ -760,9 +756,9 @@ export class LumenAgent extends Think {
             this.#turn.lazy = lazy;
         }
         const turn = this.#turn;
-        const led = withLeads(ctx.messages, `${this.#news()}${this.#screenNews()}${plan.lead ?? ''}`, this.#get('leads') ?? []);
-        this.#put('leads', led.kept);
-        const cached = cachedTurn(system, led.messages);
+        // The lead goes before the newest message only. Kept on every earlier message it grew the chat
+        // by a whole lead (an app's page, often thousands of tokens) each turn.
+        const cached = cachedTurn(system, withLead(ctx.messages, `${this.#news()}${this.#screenNews()}${plan.lead ?? ''}`));
         return {
             model: this.#model(plan, () => {
                 const fb = plan.fallback;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@columenlabs/lumen-ai",
-  "version": "0.1.265",
+  "version": "0.1.266",
   "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",
@@ -56,8 +56,8 @@
     "@ai-sdk/openai": "4.0.108",
     "@anthropic-ai/sdk": "0.133.0",
     "@cloudflare/think": "0.23.0",
-    "@columenlabs/lumen-ops": "0.1.265",
-    "@columenlabs/lumen-ui-types": "0.1.265",
+    "@columenlabs/lumen-ops": "0.1.266",
+    "@columenlabs/lumen-ui-types": "0.1.266",
     "agents": "0.32.0",
     "ai": "7.0.162",
     "just-bash": "3.6.0",