@columenlabs/lumen-ai 0.1.80 → 0.1.82

package/dist/assistant/engine.js

@@ -541,7 +541,7 @@ export class Assistant {
             }
             const page = this.cardNews(doc) +
                 (req.refs?.length
-                    ? `The person points at: ${JSON.stringify(req.refs).slice(0, 8000)}\n\n`
+                    ? `The person points at: ${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`
@@ -966,23 +966,41 @@ export class Assistant {
             // 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;
-            const stream = client.responses.stream({
-                model: session.model.id,
-                instructions,
-                input,
-                ...sent(only),
-                store: false,
-                stream: true,
-                include: ['reasoning.encrypted_content'],
-                ...(effort ? { reasoning: { effort } } : {}),
-                ...(choice ? { tool_choice: choice } : {}),
-            }, signal ? { signal } : {});
+            // 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 = '';
-            stream.on('response.output_text.delta', (e) => {
-                partial += e.delta;
-                emit('text', { delta: e.delta });
-            });
-            const res = await stream.finalResponse().catch((err) => {
+            const res = await (async () => {
+                const stream = await client.responses.create({
+                    model: session.model.id,
+                    instructions,
+                    input,
+                    ...sent(only),
+                    store: false,
+                    stream: true,
+                    include: ['reasoning.encrypted_content'],
+                    ...(effort ? { reasoning: { effort } } : {}),
+                    ...(choice ? { tool_choice: choice } : {}),
+                }, signal ? { signal } : {});
+                let done;
+                for await (const e of stream) {
+                    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') {
+                        throw new AssistantError('OpenAI could not finish the answer.', 'upstream');
+                    }
+                }
+                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 });
                 throw err;
@@ -1011,7 +1029,12 @@ export class Assistant {
             const cut = res.incomplete_details?.reason === 'max_output_tokens' ? ' …(cut)' : '';
             if (cut)
                 emit('text', { delta: cut });
-            const text = (res.output_text ?? '') + cut;
+            // Raw events carry no `output_text`: the words are the output messages' text parts.
+            const words = res.output
+                .flatMap((b) => (b.type === 'message' ? b.content : []))
+                .map((c) => (c.type === 'output_text' ? c.text : ''))
+                .join('');
+            const text = words + cut;
             if (text) {
                 answer += (answer ? '\n\n' : '') + text;
                 sink.push({ kind: 'text', text });

package/package.json

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