@moxt-ai/mobius 0.0.295 → 0.0.296

package/dist/cli.js

@@ -5398,7 +5398,7 @@ var program = new Command();
 // package.json
 var package_default = {
   name: "@moxt-ai/mobius",
-  version: "0.0.295",
+  version: "0.0.296",
   description: "Mobius CLI for pairing and running local AI agent services.",
   type: "module",
   bin: {
@@ -96846,37 +96846,44 @@ async function runRelayConnection({
 // src/runtime/relay/session-event-publisher.ts
 import { WebSocket as WebSocket8 } from "undici";
 var MAX_BUFFERED_BYTES = 32 * 1024 * 1024;
+var MAX_PENDING_BYTES2 = 32 * 1024 * 1024;
 var MAX_EVENT_BATCH_BYTES = 1024 * 1024;
 var MAX_FRAME_BYTES = 8 * 1024 * 1024;
 var LOCAL_BACKPRESSURE_CLOSE_CODE = 4009;
 var EMPTY_ENVELOPE_BYTES = Buffer.byteLength(JSON.stringify({ events: [], kind: SESSION_EVENT_KIND }));
 var SESSION_EVENT_BATCH_WINDOW_MILLISECONDS = 100;
 var RuntimeSessionEventPublisher = class {
-  #pendingEvents = [];
-  #pendingBytes = EMPTY_ENVELOPE_BYTES;
+  #pending = [];
+  #pendingBytes = 0;
+  #overflowReported = false;
   #pendingTask = null;
-  #socket = null;
+  #connection = { kind: "disconnected" };
   #timer;
   constructor(timer) {
     this.#timer = timer;
   }
   connect = (socket) => {
-    this.dropPendingEvents();
-    this.#socket = socket;
+    if (this.#connection.kind === "closed") {
+      return;
+    }
+    this.#connection = { kind: "connected", socket };
+    this.flushEvents(socket);
   };
   disconnect = (socket) => {
-    if (this.#socket === socket) {
-      this.#socket = null;
-      this.dropPendingEvents();
+    if (this.#connection.kind === "connected" && this.#connection.socket === socket) {
+      this.#connection = { kind: "disconnected" };
+      this.cancelFlush();
     }
   };
   close = () => {
-    this.#socket = null;
-    this.dropPendingEvents();
+    this.#connection = { kind: "closed" };
+    this.cancelFlush();
+    this.#pending.length = 0;
+    this.#pendingBytes = 0;
   };
   flush = () => {
-    if (this.#socket !== null) {
-      this.flushEvents(this.#socket);
+    if (this.#connection.kind === "connected") {
+      this.flushEvents(this.#connection.socket);
     }
   };
   publishOperationFailure = (sessionId, requestId, code, message) => {
@@ -96886,10 +96893,11 @@ var RuntimeSessionEventPublisher = class {
   publishInfo = (event) => this.#send(event);
   publishClosed = (event) => this.#send(event);
   #send = (message) => {
-    const socket = this.#socket;
-    if (socket === null || socket.readyState !== WebSocket8.OPEN) {
+    const connection = this.#connection;
+    if (connection.kind !== "connected" || connection.socket.readyState !== WebSocket8.OPEN) {
       return;
     }
+    const socket = connection.socket;
     const encoded = encodeDaemonToServiceMessage(message);
     if (socket.bufferedAmount + Buffer.byteLength(encoded, "utf8") > MAX_BUFFERED_BYTES) {
       socket.close(LOCAL_BACKPRESSURE_CLOSE_CODE, "Live event transport overloaded");
@@ -96901,8 +96909,7 @@ var RuntimeSessionEventPublisher = class {
     }
   };
   publish = (event) => {
-    const socket = this.#socket;
-    if (socket === null || socket.readyState !== WebSocket8.OPEN) {
+    if (this.#connection.kind === "closed") {
       return;
     }
     const bytes = Buffer.byteLength(JSON.stringify(event), "utf8") + 1;
@@ -96915,15 +96922,34 @@ var RuntimeSessionEventPublisher = class {
       });
       return;
     }
-    if (this.#pendingEvents.length > 0 && this.#pendingBytes + bytes > MAX_EVENT_BATCH_BYTES) {
-      this.flushEvents(socket);
-      if (socket.readyState !== WebSocket8.OPEN) {
-        return;
+    let batch = this.#pending.at(-1);
+    const newBatch = batch === void 0 || batch.events.length >= SESSION_EVENT_BATCH_MAX_SIZE || batch.bytes + bytes > MAX_EVENT_BATCH_BYTES;
+    const additionalBytes = bytes + (newBatch ? EMPTY_ENVELOPE_BYTES : 0);
+    if (this.#pendingBytes + additionalBytes > MAX_PENDING_BYTES2) {
+      if (!this.#overflowReported) {
+        this.#overflowReported = true;
+        console.warn("Live Session output exceeded the pending buffer limit", {
+          code: "live_event_buffer_full",
+          sessionId: event.sessionId,
+          eventId: event.eventId,
+          maximumBytes: MAX_PENDING_BYTES2
+        });
       }
+      return;
     }
-    this.#pendingEvents.push(event);
-    this.#pendingBytes += bytes;
-    if (this.#pendingEvents.length >= SESSION_EVENT_BATCH_MAX_SIZE || this.#pendingBytes >= MAX_EVENT_BATCH_BYTES) {
+    if (batch === void 0 || newBatch) {
+      batch = { events: [], bytes: EMPTY_ENVELOPE_BYTES };
+      this.#pending.push(batch);
+    }
+    batch.events.push(event);
+    batch.bytes += bytes;
+    this.#pendingBytes += additionalBytes;
+    const connection = this.#connection;
+    if (connection.kind !== "connected" || connection.socket.readyState !== WebSocket8.OPEN) {
+      return;
+    }
+    const socket = connection.socket;
+    if (this.#pending.length > 1 || batch.events.length >= SESSION_EVENT_BATCH_MAX_SIZE || batch.bytes >= MAX_EVENT_BATCH_BYTES) {
       this.flushEvents(socket);
       return;
     }
@@ -96932,29 +96958,35 @@ var RuntimeSessionEventPublisher = class {
       SESSION_EVENT_BATCH_WINDOW_MILLISECONDS
     );
   };
-  dropPendingEvents = () => {
+  cancelFlush = () => {
     this.#pendingTask?.cancel();
     this.#pendingTask = null;
-    this.#pendingEvents = [];
-    this.#pendingBytes = EMPTY_ENVELOPE_BYTES;
   };
   flushEvents = (socket) => {
-    this.#pendingTask?.cancel();
-    this.#pendingTask = null;
-    const events = this.#pendingEvents;
-    this.#pendingEvents = [];
-    this.#pendingBytes = EMPTY_ENVELOPE_BYTES;
-    if (events.length === 0 || this.#socket !== socket || socket.readyState !== WebSocket8.OPEN) {
+    this.cancelFlush();
+    const connection = this.#connection;
+    if (connection.kind !== "connected" || connection.socket !== socket || socket.readyState !== WebSocket8.OPEN) {
       return;
     }
-    const encoded = encodeDaemonToServiceMessage({ events, kind: SESSION_EVENT_KIND });
-    if (socket.bufferedAmount + Buffer.byteLength(encoded, "utf8") > MAX_BUFFERED_BYTES) {
-      socket.close(LOCAL_BACKPRESSURE_CLOSE_CODE, "Live event transport overloaded");
-      return;
+    let attempted = 0;
+    for (const batch of this.#pending) {
+      const encoded = encodeDaemonToServiceMessage({ events: batch.events, kind: SESSION_EVENT_KIND });
+      if (socket.bufferedAmount + Buffer.byteLength(encoded, "utf8") > MAX_BUFFERED_BYTES) {
+        socket.close(LOCAL_BACKPRESSURE_CLOSE_CODE, "Live event transport overloaded");
+        break;
+      }
+      attempted += 1;
+      this.#pendingBytes -= batch.bytes;
+      try {
+        socket.send(encoded);
+      } catch {
+        console.warn("Live Session output could not be sent", { code: "live_event_send_failed" });
+        break;
+      }
     }
-    try {
-      socket.send(encoded);
-    } catch {
+    this.#pending.splice(0, attempted);
+    if (this.#pending.length === 0) {
+      this.#overflowReported = false;
     }
   };
 };