@hachej/boring-agent 0.4.47 → 0.4.49

package/dist/chat-transport.js

@@ -1,3 +1,4 @@
+import { diffRevisions } from '@earendil-works/chord/delta';
 import { RequestGuardError, hasJsonContentType, readJsonBody } from '@hachej/boring-files/request-guard';
 /** Wire protocol shared with the browser client in `@hachej/boring-ui-kit/remote-chat`. */
 export const CHAT_TRANSPORT = Object.freeze({ schema: 'boring.chat-transport', version: 1, maxRequestBytes: 8_388_608, maxContextBytes: 4096, maxHistoryPage: 200, maxPendingFrames: 100, heartbeatMs: 15_000 });
@@ -60,9 +61,31 @@ function reads(conversation, context, project) {
         },
     };
 }
-/** Serialize one watch frame; with `project` a view is projected first (a throw means `projection_failed`). */
-function encodeFrame(frame, project) {
-    return JSON.stringify(frame.kind === 'view' && project ? { kind: 'view', view: project(frame.view) } : frame);
+/**
+ * Serialize the watch frames of one connection; with `project` a view is projected first (a throw means `projection_failed`).
+ * A projected viewer used to get a complete view per update, which grows with the conversation (a 60 KB prompt, then every earlier
+ * entry, ten times a second). The first frame is still the complete view; after it, an update is the operation batch between the
+ * last view this connection received and the new projected one (`diffRevisions`), which the client already replays like native
+ * operations, and the complete view when that is not smaller. Raw operations never leave the host: the batch is computed from projected views.
+ */
+function frameEncoder(project) {
+    let sent;
+    return frame => {
+        if (frame.kind !== 'view' || !project)
+            return JSON.stringify(frame);
+        // Round-tripped, so the diff is between exactly what the client holds (no `undefined` fields).
+        const full = JSON.stringify({ kind: 'view', view: project(frame.view) });
+        const next = JSON.parse(full).view;
+        if (sent !== undefined) {
+            const batch = JSON.stringify({ kind: 'ops', ops: diffRevisions(sent, next) });
+            if (batch.length < full.length / 2) {
+                sent = next;
+                return batch;
+            }
+        }
+        sent = next;
+        return full;
+    };
 }
 /** Open the conversation watch for an authenticated access, refusing a revoked one. Shared by the HTTP watch and the socket. */
 async function openWatch(access, signal) {
@@ -76,9 +99,11 @@ async function openWatch(access, signal) {
 /**
  * Stream newline-delimited JSON. A trusted viewer receives one view and then the exact native operation batches,
  * replayed in the browser with `@earendil-works/chord/delta`. With `project`, raw operations never leave the host:
- * the viewer receives complete projected views, and a slow reader gets the latest one rather than a backlog.
+ * the viewer receives one projected view, then batches between projected views (`frameEncoder`), and a slow reader gets the
+ * batch to the latest one rather than a backlog.
  */
 function stream(watch, project, signal, heartbeatMs) {
+    const encode = frameEncoder(project);
     let pending = [{ kind: 'view', view: watch.value }], wake, end, finished = false;
     // `beat` asks the next pull for a heartbeat. The timer restarts after every frame, so it fires only on an idle stream, and it is
     // cleared when the stream finishes or is cancelled: nothing outlives the response.
@@ -120,7 +145,7 @@ function stream(watch, project, signal, heartbeatMs) {
             if (frame) {
                 let line;
                 try {
-                    line = encodeFrame(frame, project);
+                    line = encode(frame);
                 }
                 catch {
                     finished = true;
@@ -416,9 +441,10 @@ export function createConversationSocketHandler(options) {
                 return null;
             }
             const { project } = access;
+            const encode = frameEncoder(project);
             const frame = (value) => {
                 try {
-                    send(socket, encodeFrame(value, project));
+                    send(socket, encode(value));
                 }
                 catch {
                     void watch.stop();

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@hachej/boring-agent",
-  "version": "0.4.47",
+  "version": "0.4.49",
   "license": "MIT",
   "private": false,
   "type": "module",
@@ -188,8 +188,8 @@
     "@earendil-works/pi-durable": "~1.4.0",
     "@earendil-works/pi-ai": "~1.4.0",
     "@earendil-works/chord": "~1.4.0",
-    "@hachej/boring-files": "^0.4.47",
-    "@hachej/boring-ui-kit": "^0.4.47",
+    "@hachej/boring-files": "^0.4.49",
+    "@hachej/boring-ui-kit": "^0.4.49",
     "typebox": "1.3.27",
     "xlsx": "^0.20.3"
   },