@columenlabs/lumen-ai 0.1.265 → 0.1.267

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/dist/assistant/engine.js

@@ -100,14 +100,28 @@ function shownError(err) {
 }
 /**
  * A plain sentence for an error OpenAI sends inside the answer's stream (an `error` event, or a
- * failed response): what happened and what to do, by its code. The code is shown when it is not
- * one we know; OpenAI's own message is only logged.
+ * failed response): what happened and what to do, by its code, with OpenAI's code in brackets so
+ * the person and the logs see the real reason. A plan's usage limit and a per-minute rate limit are
+ * different things: the first waits for the plan to reset, the second only a minute. OpenAI's own
+ * message is logged (one `assistant_upstream_error` line), never shown.
  */
-function openaiStreamError(code, plan) {
-    if (/usage_limit|usage_unavailable|insufficient_quota|rate_limit/.test(code))
+function openaiStreamError(er, plan) {
+    const code = String(er.code || er.type || '');
+    console.error(JSON.stringify({
+        event: 'assistant_upstream_error',
+        provider: 'openai',
+        plan,
+        code: er.code ?? null,
+        type: er.type ?? null,
+        message: typeof er.message === 'string' ? er.message.slice(0, 500) : null,
+    }));
+    const tag = code ? ` (${code})` : '';
+    if (/usage_limit|usage_unavailable|insufficient_quota/.test(code))
         return plan
-            ? 'Your ChatGPT plan reached its usage limit for now: try again later, or pick another model.'
-            : 'OpenAI says the key is out of quota or rate limited. Try again shortly.';
+            ? `Your ChatGPT plan reached its usage limit for now${tag}: try again later, or pick another model.`
+            : `OpenAI says the key is out of quota${tag}. Add credit to the key, or pick another model.`;
+    if (/rate_limit/.test(code))
+        return `OpenAI is rate limiting these requests${tag}: try again in a minute.`;
     if (/context_length|too_long|max_tokens/.test(code))
         return 'This chat is too long for the model. Start a new chat, or type /compact.';
     if (/model_not_found|model_not_supported|invalid_model|unsupported_model/.test(code))
@@ -115,7 +129,7 @@ function openaiStreamError(code, plan) {
             ? 'This model is not on your ChatGPT plan. Pick another model for this tier in Settings.'
             : 'OpenAI does not offer this model to the key. Pick another model for this tier in Settings.';
     if (/server_error|overloaded|timeout|unavailable/.test(code))
-        return 'OpenAI is overloaded. Try again shortly.';
+        return `OpenAI is overloaded${tag}. Try again shortly.`;
     if (/content_policy|safety|refus/.test(code))
         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.`;
@@ -1073,7 +1087,7 @@ export class Assistant {
                     done = e.response;
                 else if (e.type === 'error') {
                     const er = (e.error ?? e);
-                    throw new AssistantError(openaiStreamError(er.code || er.type || '', plan), 'upstream');
+                    throw new AssistantError(openaiStreamError(er, plan), 'upstream');
                 }
             }
         }
@@ -1081,12 +1095,16 @@ export class Assistant {
             // 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 new AssistantError(openaiStreamError(er.code || er.type || err.code || '', plan), 'upstream');
+                throw new AssistantError(openaiStreamError({
+                    ...er,
+                    code: er.code || er.type || err.code || '',
+                    message: er.message ?? err.message,
+                }, plan), 'upstream');
             }
             throw err;
         }
         if (done?.status === 'failed')
-            throw new AssistantError(openaiStreamError(done.error?.code ?? '', plan), 'upstream');
+            throw new AssistantError(openaiStreamError(done.error ?? {}, plan), 'upstream');
         const u = done?.usage;
         if (u) {
             const read = u.input_tokens_details?.cached_tokens ?? 0;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@columenlabs/lumen-ai",
-  "version": "0.1.265",
+  "version": "0.1.267",
   "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.267",
+    "@columenlabs/lumen-ui-types": "0.1.267",
     "agents": "0.32.0",
     "ai": "7.0.162",
     "just-bash": "3.6.0",