@columenlabs/lumen-ai 0.1.99 → 0.1.101

package/dist/assistant/engine.js

@@ -155,6 +155,14 @@ 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.`;
 }
+/** Set once a plan backend refuses `max_output_tokens`, for the rest of the isolate. */
+let planCapRefused = false;
+const refusesCap = (err) => err instanceof OpenAI.APIError &&
+    err.status === 400 &&
+    /max_output_tokens/.test(`${err.message} ${err.error?.param ?? ''}`);
+/** 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;
 export class Assistant {
     o;
@@ -1093,7 +1101,9 @@ export class Assistant {
             strict: false,
         }));
         // The chat so far is plain text turns; this answer's calls are appended as OpenAI items.
-        const input = o.messages.map((m) => ({
+        // 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
@@ -1101,15 +1111,19 @@ export class Assistant {
                     .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.
-        const sent = (only) => {
+        // A plan sign-in takes function tools only inside a namespace. Its output cap is sent too,
+        // unless the backend refused one before (then it keeps its own).
+        const sent = (only, cap) => {
             const fns = only ? fnTools.filter((t) => t.name === only) : fnTools;
+            const out = cap ? { max_output_tokens: session.tier.out ?? DEFAULT_OUT } : {};
             if (!plan)
-                return { tools: fns, max_output_tokens: session.tier.out ?? DEFAULT_OUT };
+                return { tools: fns, ...out };
             return {
+                ...out,
                 tools: [
                     {
                         type: 'namespace',
@@ -1132,8 +1146,8 @@ export class Assistant {
             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`.
-            const seen = {};
-            const items = [];
+            let seen = {};
+            let items = [];
             // An error OpenAI sends inside the stream: logged in full, shown as a plain sentence.
             const streamFailure = (er) => {
                 if (partial)
@@ -1150,16 +1164,24 @@ export class Assistant {
                 }));
                 return new AssistantError(openaiStreamError(er.code || er.type || '', plan), 'upstream');
             };
-            const res = await (async () => {
+            // One call of this round; asked again (fresh stream state) when the plan refuses the cap or
+            // spends its whole output on reasoning.
+            const ask = (cap, eff) => {
+                partial = '';
+                seen = {};
+                items = [];
+                return askOnce(cap, eff);
+            };
+            const askOnce = (cap, eff) => (async () => {
                 const stream = await client.responses.create({
                     model: session.model.id,
                     instructions,
                     input,
-                    ...sent(only),
+                    ...sent(only, cap),
                     store: false,
                     stream: true,
                     include: ['reasoning.encrypted_content'],
-                    ...(effort ? { reasoning: { effort } } : {}),
+                    ...(eff ? { reasoning: { effort: eff } } : {}),
                     ...(choice ? { tool_choice: choice } : {}),
                 }, signal ? { signal } : {});
                 let done;
@@ -1198,6 +1220,38 @@ export class Assistant {
                 }
                 throw err;
             });
+            let cap = !plan || !planCapRefused;
+            let res;
+            try {
+                res = await ask(cap, effort);
+            }
+            catch (err) {
+                // A plan backend that refuses an output cap keeps its own: ask once more without it.
+                if (!(plan && cap && refusesCap(err)))
+                    throw err;
+                planCapRefused = true;
+                cap = false;
+                console.error(JSON.stringify({ event: 'assistant_openai_cap_refused', model: session.model.id }));
+                res = await ask(cap, effort);
+            }
+            // A reasoning model can spend the whole output on thinking and say nothing: ask once more
+            // with less thinking before giving up.
+            if (res.status === 'incomplete' &&
+                res.incomplete_details?.reason === 'max_output_tokens' &&
+                !partial &&
+                !shows(res.output?.length ? res.output : items) &&
+                effort !== 'low') {
+                console.error(JSON.stringify({
+                    event: 'assistant_openai_retry',
+                    model: session.model.id,
+                    plan,
+                    cap,
+                    why: 'no_words',
+                    usage: res.usage ?? null,
+                    events: seen,
+                }));
+                res = await ask(cap, 'low');
+            }
             if (res.status === 'failed') {
                 if (partial)
                     sink.push({ kind: 'text', text: partial });
@@ -1247,9 +1301,11 @@ export class Assistant {
                     parts: output.flatMap((b) => b.type === 'message' ? b.content.map((c) => c.type) : []),
                 }));
                 if (!answer)
-                    throw new AssistantError(res.incomplete_details?.reason
-                        ? `OpenAI stopped before answering (${res.incomplete_details.reason}).`
-                        : 'OpenAI sent no answer.', 'upstream');
+                    throw new AssistantError(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)'

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@columenlabs/lumen-ai",
-  "version": "0.1.99",
+  "version": "0.1.101",
   "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.99",
-    "@columenlabs/lumen-ui-types": "0.1.99",
+    "@columenlabs/lumen-ops": "0.1.101",
+    "@columenlabs/lumen-ui-types": "0.1.101",
     "openai": "7.32.0",
     "zod": "^4.3.6"
   },