@cryptiklemur/lattice 5.13.2 → 5.13.4

package/dist/server/project/sdk-bridge.js

@@ -41,38 +41,59 @@ const sessionPermissionOverrides = new Map();
 export function getAvailableModels() {
     return getWarmupModels();
 }
-function createMessageQueue() {
+function createMessageQueue(label) {
     const queue = [];
     let waiting = null;
     let ended = false;
+    let readCount = 0;
+    const readWaiters = new Map();
     return {
         push: function (msg) {
             if (waiting) {
+                log.chat("MQ[%s] push: SDK was waiting, delivering immediately (queued=%d)", label || "?", queue.length);
                 const resolve = waiting;
                 waiting = null;
                 resolve({ value: msg, done: false });
             }
             else {
                 queue.push(msg);
+                log.chat("MQ[%s] push: buffered (queued=%d)", label || "?", queue.length);
             }
         },
         end: function () {
             ended = true;
+            log.chat("MQ[%s] end called (queued=%d, waiting=%s)", label || "?", queue.length, String(!!waiting));
             if (waiting) {
                 const resolve = waiting;
                 waiting = null;
                 resolve({ value: undefined, done: true });
             }
         },
+        waitForRead: function (n) {
+            if (readCount >= n)
+                return Promise.resolve();
+            return new Promise(function (resolve) {
+                readWaiters.set(n, resolve);
+            });
+        },
         [Symbol.asyncIterator]: function () {
             return {
                 next: function () {
+                    readCount++;
+                    const waiter = readWaiters.get(readCount);
+                    if (waiter) {
+                        readWaiters.delete(readCount);
+                        waiter();
+                    }
                     if (queue.length > 0) {
+                        log.chat("MQ[%s] read #%d: from buffer (remaining=%d)", label || "?", readCount, queue.length - 1);
                         return Promise.resolve({ value: queue.shift(), done: false });
                     }
                     if (ended) {
+                        log.chat("MQ[%s] read #%d: ended", label || "?", readCount);
                         return Promise.resolve({ value: undefined, done: true });
                     }
+                    log.chat("MQ[%s] read #%d: waiting for push", label || "?", readCount);
                     return new Promise(function (resolve) {
                         waiting = resolve;
                     });
@@ -654,7 +675,7 @@ export function startChatStream(options) {
         text,
         uuid: crypto.randomUUID(),
     });
-    const mq = createMessageQueue();
+    const mq = createMessageQueue(sessionId.slice(0, 8));
     const firstMsg = buildSDKUserMessage(prompt, attachments, sessionId);
     const stream = query({ prompt: mq, options: queryOptions });
     pendingStreams.delete(sessionId);
@@ -695,20 +716,47 @@ export function startChatStream(options) {
         catch (initErr) {
             log.chat("Session %s SDK initialization FAILED: %O", sessionId, initErr);
         }
-        log.chat("Session %s pushing first message to queue", sessionId);
+        if (shouldResume) {
+            log.chat("Session %s waiting for SDK read #2 before pushing message", sessionId);
+            await mq.waitForRead(2);
+            log.chat("Session %s SDK read #2 triggered, pushing first message", sessionId);
+        }
+        else {
+            log.chat("Session %s pushing first message to queue", sessionId);
+        }
         mq.push(firstMsg);
         let retrying = false;
+        const TURN_TIMEOUT_MS = 30000;
+        let turnTimer = null;
+        function resetTurnTimer() {
+            if (turnTimer)
+                clearTimeout(turnTimer);
+            turnTimer = setTimeout(function () {
+                if (!sessionStream.sawNewTurnContent && !sessionStream.ended) {
+                    log.chat("Session %s turn timeout: no new content after %dms, aborting", sessionId, TURN_TIMEOUT_MS);
+                    abortController.abort();
+                }
+            }, TURN_TIMEOUT_MS);
+        }
+        resetTurnTimer();
         try {
             log.chat("Session %s entering stream loop", sessionId);
             let msgCount = 0;
             for await (const msg of stream) {
                 msgCount++;
                 log.chat("Session %s msg #%d type=%s", sessionId, msgCount, msg.type);
+                if (msg.type === "stream_event" || (msg.type === "assistant" && msg.message?.model !== "<synthetic>")) {
+                    resetTurnTimer();
+                }
                 processMessage(sessionStream, msg);
             }
+            if (turnTimer)
+                clearTimeout(turnTimer);
             log.chat("Session %s stream ended normally after %d messages", sessionId, msgCount);
         }
         catch (err) {
+            if (turnTimer)
+                clearTimeout(turnTimer);
             const errMsg = err instanceof Error ? err.message : String(err);
             log.chat("Session %s stream error: %s", sessionId, errMsg);
             if (errMsg.includes("aborted") || errMsg.includes("AbortError")) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@cryptiklemur/lattice",
-  "version": "5.13.2",
+  "version": "5.13.4",
   "description": "Multi-machine agentic dashboard for Claude Code. Monitor sessions, manage MCP servers and skills, orchestrate across mesh-networked nodes.",
   "license": "MIT",
   "author": "Aaron Scherer <me@aaronscherer.me>",