@addai/node 0.21.0 → 0.22.0

package/dist/codex-spawn.js

@@ -47,6 +47,7 @@ const child_process_1 = require("child_process");
 const fs = __importStar(require("fs"));
 const os = __importStar(require("os"));
 const path = __importStar(require("path"));
+const think_split_1 = require("./think-split");
 const codex_binary_1 = require("./codex-binary");
 const diskguard_1 = require("./diskguard");
 const win_1 = require("./win");
@@ -318,6 +319,10 @@ function spawnCodex(input) {
             kill() { },
         };
     }
+    // Models do not reliably keep reasoning on their own stream — they drop
+    // back to ordinary text mid-run and carry on thinking inside a <think>
+    // tag. Split it back out before it reaches the room. See think-split.ts.
+    const emitSplit = (0, think_split_1.splittingEmitter)(emit);
     proc.stdout?.on('data', (chunk) => {
         touchActivity();
         buffer += chunk.toString('utf8');
@@ -338,7 +343,7 @@ function spawnCodex(input) {
                 threadId = parsed.thread_id;
             }
             for (const ev of lineToEvents(parsed))
-                emit(ev);
+                emitSplit(ev);
         }
     });
     proc.stderr?.on('data', (chunk) => {
@@ -354,7 +359,13 @@ function spawnCodex(input) {
         // SIGINT from kill()/timeout, or async spawn error). DiskGuard is the
         // backstop for the paths this can't cover — SIGKILL and crashes.
         proc.once('error', (err) => { void guardSession.dispose(true); reject(err); });
-        proc.once('exit', (code) => { void guardSession.dispose(true); resolve(code ?? -1); });
+        proc.once('exit', (code) => {
+            // Release anything the splitter is still holding — a run that ends
+            // mid-tag must not lose the tail of its answer.
+            emitSplit.flush();
+            void guardSession.dispose(true);
+            resolve(code ?? -1);
+        });
     });
     return {
         pid: proc.pid,

package/dist/desktop/relay-client.d.ts

@@ -1,2 +1,7 @@
+/** What to run when the server says there is work. Injected by index.ts so
+ *  this module stays ignorant of the pumps it is nudging. */
+type WakeKind = 'command' | 'request';
+export declare function onWake(kind: WakeKind, fn: () => void): void;
 export declare function startRelayClient(): void;
 export declare function stopRelayClient(): void;
+export {};

package/dist/desktop/relay-client.js

@@ -36,16 +36,23 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.onWake = onWake;
 exports.startRelayClient = startRelayClient;
 exports.stopRelayClient = stopRelayClient;
-// Dial-out socket to the desktop relay.
+// Dial-out socket to the relay — this node's live link to the server.
 //
-// The daemon connects OUT whenever it has a running desktop, so there is no
-// inbound port and no NAT problem - and because the socket is already open,
-// attaching a viewer is instant rather than waiting on the 30s heartbeat.
+// The daemon connects OUT, so there is no inbound port and no NAT problem.
+// It is held open ALWAYS, not only while a desktop is running, because it is
+// how the server reaches this machine without being asked: work queued in
+// Studio is pushed down here the moment it exists instead of waiting for the
+// 30s heartbeat to notice it. That heartbeat remains the fallback for a node
+// whose socket is down; this is the fast path, not the only path.
 //
-// It carries RAW RFB bytes. The container serves RFB directly (no websockify),
-// so noVNC in the browser speaks RFB across this pipe unchanged.
+// Two kinds of traffic share it:
+//   - RAW RFB bytes for desktop viewers. The container serves RFB directly
+//     (no websockify), so noVNC in the browser speaks RFB across it unchanged.
+//   - `wake` control frames, which cost nothing when idle and turn a ten
+//     second wait into a round trip.
 const ws_1 = __importDefault(require("ws"));
 const net = __importStar(require("net"));
 const store_1 = require("../store");
@@ -55,7 +62,7 @@ const RELAY_URL = process.env.AINODE_RELAY_URL
     ?? 'wss://desktop-relay-29522465016.europe-west2.run.app';
 const RECONNECT_MIN_MS = 2_000;
 const RECONNECT_MAX_MS = 60_000;
-/** Re-check whether any desktop is running this often while idle. */
+/** Re-check for a pairing token this often when there is not one yet. */
 const IDLE_CHECK_MS = 60_000;
 /** How often to prove the socket is still alive. A machine that suspends
  *  leaves a half-open socket that never fires 'close', so without this the
@@ -73,6 +80,10 @@ let missedPongs = 0;
  *  people watching the same screen each need their own connection and their
  *  own handshake. x11vnc runs with -shared precisely so it will serve them. */
 const bridges = new Map();
+const wakeHooks = new Map();
+function onWake(kind, fn) {
+    wakeHooks.set(kind, fn);
+}
 function dropBridges() {
     for (const s of bridges.values()) {
         try {
@@ -82,14 +93,6 @@ function dropBridges() {
     }
     bridges.clear();
 }
-async function anyDesktopRunning() {
-    try {
-        return (await (0, manager_1.listDesktops)()).some(d => d.status === 'running');
-    }
-    catch {
-        return false;
-    }
-}
 function scheduleReconnect() {
     if (stopped)
         return;
@@ -104,11 +107,6 @@ async function connect() {
         scheduleReconnect();
         return;
     }
-    // No point holding a socket open for a machine with nothing to show.
-    if (!(await anyDesktopRunning())) {
-        idleTimer = setTimeout(() => { void connect(); }, IDLE_CHECK_MS);
-        return;
-    }
     const sock = new ws_1.default(`${RELAY_URL}/node?token=${encodeURIComponent(token)}`);
     ws = sock;
     sock.on('open', () => {
@@ -173,6 +171,26 @@ async function connect() {
             bridges.get(msg.viewerId)?.write(Buffer.from(msg.b64, 'base64'));
             return;
         }
+        if (msg.type === 'wake') {
+            // The whole point of the socket. Costs one function call; saves the
+            // wait for the next heartbeat.
+            const kind = msg.what;
+            const hook = kind ? wakeHooks.get(kind) : undefined;
+            if (hook) {
+                try {
+                    hook();
+                }
+                catch { /* a pump must never kill the link */ }
+            }
+            else
+                for (const h of wakeHooks.values()) {
+                    try {
+                        h();
+                    }
+                    catch { /* as above */ }
+                }
+            return;
+        }
         if (msg.type === 'detach') {
             bridges.get(msg.viewerId)?.destroy();
             bridges.delete(msg.viewerId);

package/dist/gemini-spawn.js

@@ -54,6 +54,7 @@ const path = __importStar(require("path"));
 const gemini_binary_1 = require("./gemini-binary");
 const win_1 = require("./win");
 const events_1 = require("./events");
+const think_split_1 = require("./think-split");
 /**
  * Write a workspace-scope `<cwd>/.gemini/settings.json` for THIS spawn.
  *
@@ -300,6 +301,10 @@ function spawnGemini(input) {
             done: Promise.resolve(-1),
         };
     }
+    // Models do not reliably keep reasoning on their own stream — they drop
+    // back to ordinary text mid-run and carry on thinking inside a <think>
+    // tag. Split it back out before it reaches the room. See think-split.ts.
+    const emitSplit = (0, think_split_1.splittingEmitter)(emit);
     proc.stdout?.on('data', (chunk) => {
         buffer += chunk.toString('utf8');
         let nl;
@@ -318,7 +323,7 @@ function spawnGemini(input) {
             if (typeof parsed.session_id === 'string' && !sessionId)
                 sessionId = parsed.session_id;
             for (const ev of lineToEvents(parsed))
-                emit(ev);
+                emitSplit(ev);
         }
     });
     proc.stderr?.on('data', (chunk) => {
@@ -349,10 +354,13 @@ function spawnGemini(input) {
                     if (typeof parsed.session_id === 'string' && !sessionId)
                         sessionId = parsed.session_id;
                     for (const ev of lineToEvents(parsed))
-                        emit(ev);
+                        emitSplit(ev);
                 }
                 catch { /* ignore a partial/non-JSON tail */ }
             }
+            // Release anything the splitter is still holding — a run that ends
+            // mid-tag must not lose the tail of its answer.
+            emitSplit.flush();
             // No HOME-temp-dir to clean up anymore. The workspace settings file in
             // <cwd>/.gemini/settings.json sits with the rest of the ephemeral cwd
             // and is cleaned by the session dispose path.

package/dist/grok-spawn.js

@@ -73,6 +73,7 @@ const path = __importStar(require("path"));
 const grok_binary_1 = require("./grok-binary");
 const win_1 = require("./win");
 const events_1 = require("./events");
+const think_split_1 = require("./think-split");
 /** Real config dir for the logged-in account. GROK_HOME points here so the
  *  entity uses the same account and token refresh works. */
 function realGrokHome() {
@@ -415,25 +416,52 @@ function spawnGrok(input) {
             emit({ type: 'assistant_text', delta });
         }
     };
+    // grok does not always keep reasoning on the `thought` stream: mid-run it
+    // will drop back to ordinary text and carry on thinking inside a <think>
+    // tag. Everything visible therefore goes through the splitter first, so
+    // private working never lands in the room. See think-split.ts.
+    const splitter = (0, think_split_1.createThinkSplitter)();
+    /** Visible answer text, already known not to be reasoning. */
+    const appendText = (delta) => {
+        // Thoughts precede the text they produced — flush them first.
+        flushThinking();
+        textBuf += delta;
+        if (textBuf.length >= MAX_BUF)
+            flushText();
+        else if (!flushTimer)
+            flushTimer = setTimeout(flushText, FLUSH_MS);
+    };
+    const appendThinking = (delta) => {
+        thinkBuf += delta;
+        if (thinkBuf.length >= THINK_MAX_BUF)
+            flushThinking();
+        else if (!thinkTimer)
+            thinkTimer = setTimeout(flushThinking, THINK_FLUSH_MS);
+    };
     const emitCoalesced = (e) => {
         if (e.type === 'assistant_text') {
-            // Thoughts precede the text they produced — flush them first.
-            flushThinking();
-            textBuf += e.delta;
-            if (textBuf.length >= MAX_BUF)
-                flushText();
-            else if (!flushTimer)
-                flushTimer = setTimeout(flushText, FLUSH_MS);
+            // A delta may be part answer and part reasoning, or may end halfway
+            // through a tag — the splitter holds back whatever is still ambiguous.
+            for (const part of splitter.push(e.delta)) {
+                if (part.type === 'thinking')
+                    appendThinking(part.delta);
+                else if (part.type === 'assistant_text')
+                    appendText(part.delta);
+            }
         }
         else if (e.type === 'thinking') {
-            thinkBuf += e.delta;
-            if (thinkBuf.length >= THINK_MAX_BUF)
-                flushThinking();
-            else if (!thinkTimer)
-                thinkTimer = setTimeout(flushThinking, THINK_FLUSH_MS);
+            appendThinking(e.delta);
         }
         else {
-            // Any other event must appear AFTER the stream so far — flush both.
+            // Any other event must appear AFTER the stream so far. Release whatever
+            // the splitter is still holding: a run that ends mid-tag must not eat
+            // the tail of the answer.
+            for (const part of splitter.flush()) {
+                if (part.type === 'thinking')
+                    appendThinking(part.delta);
+                else if (part.type === 'assistant_text')
+                    appendText(part.delta);
+            }
             flushThinking();
             flushText();
             emit(e);

package/dist/index.js

@@ -210,7 +210,12 @@ async function start(argv = []) {
     (0, projects_1.start)();
     // …and to keep desktops and the containers behind them in agreement.
     (0, manager_1.startDesktopManager)();
-    // …and dial out to the relay so a running desktop is watchable from Studio.
+    // …and dial out to the relay. That socket is this node's live link: the
+    // server pushes work down it the instant it exists, so a command no longer
+    // waits up to 30s for the next heartbeat to notice it. The heartbeat and
+    // the request pump still run — this makes them the fallback, not the clock.
+    (0, relay_client_1.onWake)('command', command_runner_1.wake);
+    (0, relay_client_1.onWake)('request', request_pump_1.pumpNow);
     (0, relay_client_1.startRelayClient)();
     let stopped = false;
     // Outcome of the last drain, so a remote roll can report whether it left

package/dist/kimi-spawn.js

@@ -51,6 +51,7 @@ const path = __importStar(require("path"));
 const kimi_binary_1 = require("./kimi-binary");
 const win_1 = require("./win");
 const events_1 = require("./events");
+const think_split_1 = require("./think-split");
 /** Write a sandbox $HOME with an empty .kimi dir so kimi's default
  *  `~/.kimi/mcp.json` resolves to nothing. Caller is responsible for
  *  cleanup (we drop it under os.tmpdir() so the OS reaps it). */
@@ -269,6 +270,10 @@ function spawnKimi(input) {
             done: Promise.resolve(-1),
         };
     }
+    // Models do not reliably keep reasoning on their own stream — they drop
+    // back to ordinary text mid-run and carry on thinking inside a <think>
+    // tag. Split it back out before it reaches the room. See think-split.ts.
+    const emitSplit = (0, think_split_1.splittingEmitter)(emit);
     proc.stdout?.on('data', (chunk) => {
         touchActivity();
         buffer += chunk.toString('utf8');
@@ -288,7 +293,7 @@ function spawnKimi(input) {
             if (typeof parsed.session_id === 'string' && !sessionId)
                 sessionId = parsed.session_id;
             for (const ev of lineToEvents(parsed))
-                emit(ev);
+                emitSplit(ev);
         }
     });
     proc.stderr?.on('data', (chunk) => {
@@ -300,6 +305,9 @@ function spawnKimi(input) {
     const done = new Promise((resolve, reject) => {
         proc.once('error', reject);
         proc.once('exit', (code) => {
+            // Release anything the splitter is still holding — a run that ends
+            // mid-tag must not lose the tail of its answer.
+            emitSplit.flush();
             // Best-effort cleanup of sandbox tmp dir
             try {
                 fs.rmSync(kimiSandboxDir, { recursive: true, force: true });

package/dist/request-pump.d.ts

@@ -2,6 +2,16 @@ export declare function inflightCount(): number;
 export declare function activeRequestIdList(): string[];
 export declare function start(): void;
 export declare function stop(): void;
+/**
+ * Pick up work right now, because the server said there is some.
+ *
+ * Called from the relay socket's `wake`. Deliberately does NOT clear
+ * `nextPickAllowedAt`: if the pump is backing off because Supabase is
+ * unhealthy, a push is no reason to start hammering it again — the backoff
+ * exists to protect the connection pool, and a wake that ignored it would
+ * reintroduce exactly the pile-up it was added to stop.
+ */
+export declare function pumpNow(): void;
 /**
  * Wait for all in-flight requests to finish, with a hard ceiling so a
  * hung spawn can't block daemon shutdown forever. Resolves when either

package/dist/request-pump.js

@@ -8,6 +8,7 @@ exports.inflightCount = inflightCount;
 exports.activeRequestIdList = activeRequestIdList;
 exports.start = start;
 exports.stop = stop;
+exports.pumpNow = pumpNow;
 exports.drain = drain;
 const supabase_client_1 = require("./supabase-client");
 const store_1 = require("./store");
@@ -236,6 +237,20 @@ function stop() {
         timer = null;
     }
 }
+/**
+ * Pick up work right now, because the server said there is some.
+ *
+ * Called from the relay socket's `wake`. Deliberately does NOT clear
+ * `nextPickAllowedAt`: if the pump is backing off because Supabase is
+ * unhealthy, a push is no reason to start hammering it again — the backoff
+ * exists to protect the connection pool, and a wake that ignored it would
+ * reintroduce exactly the pile-up it was added to stop.
+ */
+function pumpNow() {
+    if (stopped)
+        return;
+    void tick();
+}
 /**
  * Wait for all in-flight requests to finish, with a hard ceiling so a
  * hung spawn can't block daemon shutdown forever. Resolves when either

package/dist/think-split.d.ts

@@ -0,0 +1,24 @@
+import type { RuntimeEvent } from './types';
+export interface ThinkSplitter {
+    /** Feed one visible-text delta; get back correctly-typed events. */
+    push(delta: string): RuntimeEvent[];
+    /** End of stream: release anything held back. */
+    flush(): RuntimeEvent[];
+    /** True while inside a reasoning region — the run ended mid-thought. */
+    get open(): boolean;
+}
+export declare function createThinkSplitter(): ThinkSplitter;
+/**
+ * Wrap a harness's `emit` so visible text is split before it leaves.
+ *
+ * Harnesses map one JSON line to events with a pure function and emit them in
+ * a loop, so there is no natural place to keep splitter state. This holds it,
+ * and releases anything held back as soon as a non-text event arrives — the
+ * tail of an answer must never sit hostage behind a tool call.
+ */
+export interface SplittingEmit {
+    (e: RuntimeEvent): void;
+    /** End of stream: release whatever is still held. */
+    flush(): void;
+}
+export declare function splittingEmitter(emit: (e: RuntimeEvent) => void): SplittingEmit;

package/dist/think-split.js

@@ -0,0 +1,103 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createThinkSplitter = createThinkSplitter;
+exports.splittingEmitter = splittingEmitter;
+/** Openers seen in the wild across grok, qwen, deepseek-style outputs. The
+ *  closer is the same word, so one list drives both. */
+const TAGS = ['think', 'thinking', 'thought', 'reason', 'reasoning', 'antml'];
+/** Longest string we might have to hold back: `</reasoning>` plus slack. */
+const MAX_HOLD = 14;
+function openerAt(buf, i) {
+    if (buf[i] !== '<')
+        return null;
+    for (const tag of TAGS) {
+        const open = `<${tag}>`;
+        if (buf.slice(i, i + open.length).toLowerCase() === open)
+            return { tag, len: open.length };
+    }
+    return null;
+}
+function closerAt(buf, i, tag) {
+    const close = `</${tag}>`;
+    return buf.slice(i, i + close.length).toLowerCase() === close ? close.length : null;
+}
+/** True when the tail of `buf` from `i` could still grow into a tag. */
+function couldBecomeTag(buf, i) {
+    const tail = buf.slice(i).toLowerCase();
+    if (!tail.startsWith('<'))
+        return false;
+    const body = tail.startsWith('</') ? tail.slice(2) : tail.slice(1);
+    return TAGS.some(t => t.startsWith(body)) || body.length === 0;
+}
+function createThinkSplitter() {
+    let buf = '';
+    let inside = null;
+    function drain(final) {
+        const out = [];
+        let text = '';
+        let think = '';
+        let i = 0;
+        while (i < buf.length) {
+            if (inside === null) {
+                const open = openerAt(buf, i);
+                if (open) {
+                    inside = open.tag;
+                    i += open.len;
+                    continue;
+                }
+                if (!final && couldBecomeTag(buf, i) && buf.length - i < MAX_HOLD)
+                    break;
+                text += buf[i];
+                i += 1;
+            }
+            else {
+                const close = closerAt(buf, i, inside);
+                if (close !== null) {
+                    inside = null;
+                    i += close;
+                    continue;
+                }
+                if (!final && couldBecomeTag(buf, i) && buf.length - i < MAX_HOLD)
+                    break;
+                think += buf[i];
+                i += 1;
+            }
+        }
+        buf = buf.slice(i);
+        if (think)
+            out.push({ type: 'thinking', delta: think });
+        if (text)
+            out.push({ type: 'assistant_text', delta: text });
+        return out;
+    }
+    return {
+        push(delta) {
+            if (!delta)
+                return [];
+            buf += delta;
+            return drain(false);
+        },
+        flush() {
+            // Whatever is left is real output, tag or not — never silently swallow
+            // the tail of an answer because it happened to look like markup.
+            return drain(true);
+        },
+        get open() { return inside !== null; },
+    };
+}
+function splittingEmitter(emit) {
+    const splitter = createThinkSplitter();
+    const release = () => { for (const part of splitter.flush())
+        emit(part); };
+    const out = ((e) => {
+        if (e.type === 'assistant_text') {
+            for (const part of splitter.push(e.delta))
+                emit(part);
+            return;
+        }
+        release();
+        emit(e);
+    });
+    out.flush = release;
+    return out;
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@addai/node",
-  "version": "0.21.0",
+  "version": "0.22.0",
   "description": "Daemon that pairs a machine with your +Ai account and runs Claude / Codex / Kimi / Gemini agents on its behalf. Reachable via Supabase from Vault, Entity Studio, or any other +Ai surface.",
   "license": "MIT",
   "keywords": [