@evandu/super-pi 0.1.70 → 0.1.72

package/dist/server/types.d.ts

@@ -94,6 +94,10 @@ export type Message = {
     piEntryId?: string;
     toolCalls?: ToolCallBlock[];
     thinking?: string;
+    thinkingBlocks?: {
+        at: number;
+        text: string;
+    }[];
     images?: MessageImage[];
     attachments?: MessageAttachments;
     agentIdentity?: {
@@ -241,11 +245,17 @@ export type ToolCallNotice = {
  * - read out of the arguments as far as they have arrived. It is `undefined` when nothing identifying has
  * been written yet, which is a different fact from an empty one: the caller has a placeholder word for the
  * second case and must not invent one for the first.
+ *
+ * `live` is the arguments AS THEY STAND - the whole text written so far, never the newest fragment alone.
+ * It shares its meaning with `tool_execution_update`'s output (which Pi sends already accumulated), so one
+ * field with two meanings would make the caller store one kind of text by appending and the other by
+ * replacing - which is a flicker and a duplication at once. Pi sends argument fragments raw; accumulating
+ * them is the runtime's job, where the fragments already are.
  */
 export interface ToolCallPreparing {
     contentIndex: number;
     name: string;
-    delta?: string;
+    live?: string;
     detail?: string;
 }
 /**
@@ -315,6 +325,9 @@ export type Conversation = {
     status: RunStatus;
     messages: Message[];
     archivedAt?: string;
+    /** Pi's own resolved transcript path, observed from this conversation's live worker. It is only a
+     * locator: revert still verifies the file header and every retained boundary before writing. */
+    piSessionFile?: string;
     /** Set when the user explicitly names the session; automatic first-message titles must not overwrite it. */
     titleLocked?: boolean;
     /**
@@ -912,6 +925,11 @@ export type ClientCommandBody =
     type: "catalog.fetch";
     conversationId?: string;
 }
+/** Enables bounded transport coalescing for high-frequency streaming events on this socket. */
+ | {
+    type: "stream.configure";
+    coalesce: boolean;
+}
 /** Asks for the agent catalog read from disk. Answered by `agent.catalog`. */
  | {
     type: "agent.catalog.fetch";
@@ -1080,6 +1098,7 @@ export type ServerEvent = {
     messageId: string;
     delta: string;
     active: boolean;
+    at?: number;
 }
 /**
  * THE ANSWER TO `conversation.fork`, as ONE event with an `ok` discriminant rather than two events or a

package/dist/server/ws-server.d.ts

@@ -11,9 +11,14 @@ import type { CatalogService } from "./application/catalog-service.js";
 export declare class WsBroadcaster implements EventBroadcaster {
     private readonly getState;
     private readonly sockets;
+    private readonly coalescedSockets;
+    private readonly pendingStreams;
     constructor(getState: () => AppState);
     register(socket: WebSocket): void;
     unregister(socket: WebSocket): void;
+    configureStreaming(socket: WebSocket, coalesce: boolean): void;
+    private flushStreaming;
+    private enqueueStreaming;
     getSockets(): Set<WebSocket>;
     broadcast(event: ServerEvent): void;
     broadcastState(): void;

package/dist/server/ws-server.js

@@ -7,6 +7,8 @@ import { isAuthorized } from "./http-server.js";
 export class WsBroadcaster {
     getState;
     sockets = new Set();
+    coalescedSockets = new Set();
+    pendingStreams = new Map();
     constructor(getState) {
         this.getState = getState;
     }
@@ -14,16 +16,56 @@ export class WsBroadcaster {
         this.sockets.add(socket);
     }
     unregister(socket) {
+        this.coalescedSockets.delete(socket);
+        const pending = this.pendingStreams.get(socket);
+        if (pending)
+            clearTimeout(pending.timer);
+        this.pendingStreams.delete(socket);
         this.sockets.delete(socket);
     }
+    configureStreaming(socket, coalesce) {
+        if (coalesce)
+            this.coalescedSockets.add(socket);
+        else {
+            this.flushStreaming(socket);
+            this.coalescedSockets.delete(socket);
+        }
+    }
+    flushStreaming(socket) {
+        const pending = this.pendingStreams.get(socket);
+        if (!pending)
+            return;
+        clearTimeout(pending.timer);
+        this.pendingStreams.delete(socket);
+        for (const event of pending.events.values())
+            if (socket.readyState === WebSocket.OPEN)
+                socket.send(JSON.stringify(event));
+    }
+    enqueueStreaming(socket, event) {
+        let pending = this.pendingStreams.get(socket);
+        if (!pending) {
+            const events = new Map();
+            pending = { events, timer: setTimeout(() => this.flushStreaming(socket), 16) };
+            this.pendingStreams.set(socket, pending);
+        }
+        const key = `${event.type}\u0000${event.conversationId}\u0000${event.messageId}`;
+        const previous = pending.events.get(key);
+        pending.events.set(key, previous ? { ...previous, delta: previous.delta + event.delta } : event);
+    }
     getSockets() {
         return this.sockets;
     }
     broadcast(event) {
-        const payload = JSON.stringify(event);
+        const streaming = event.type === "message.delta" || event.type === "message.thinking";
         for (const socket of this.sockets) {
-            if (socket.readyState === WebSocket.OPEN) {
-                socket.send(payload);
+            if (socket.readyState !== WebSocket.OPEN)
+                continue;
+            if (streaming && this.coalescedSockets.has(socket))
+                this.enqueueStreaming(socket, event);
+            else {
+                // A state/tool/lifecycle event is a transcript boundary. Flush its preceding text first.
+                this.flushStreaming(socket);
+                socket.send(JSON.stringify(event));
             }
         }
     }
@@ -169,6 +211,10 @@ export class WsServer {
                     socket.send(JSON.stringify({ type: "error", message: "command failed" }));
                     return;
                 }
+                if (parsed.type === "stream.configure") {
+                    this.broadcaster.configureStreaming(socket, parsed.coalesce);
+                    return;
+                }
                 // A send represents a streaming operation. It must be admitted immediately so a second send
                 // can observe the active run and enter the durable follow-up queue; waiting for the first model
                 // turn here makes every follow-up test time out and defeats the queue semantics.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@evandu/super-pi",
-  "version": "0.1.70",
+  "version": "0.1.72",
   "description": "Web control plane and companion for Pi",
   "license": "MIT",
   "type": "module",
@@ -34,6 +34,8 @@
     "check": "node scripts/run-check.mjs"
   },
   "check:logic": [
+    "scripts/stream-checkpoint.test.mjs",
+    "scripts/stream-transport.test.mjs",
     "scripts/lan-access.test.mjs",
     "scripts/terminal-pty.test.mjs",
     "scripts/persistence-repository.test.mjs",
@@ -69,7 +71,6 @@
     "scripts/revert-session-format.test.mjs",
     "scripts/revert-session-file.test.mjs",
     "scripts/revert-real-pi.test.mjs",
-    "scripts/revert-browser.test.mjs",
     "scripts/bg-task.test.mjs",
     "scripts/todo-tool.test.mjs",
     "scripts/tool-calls.test.mjs",
@@ -84,6 +85,7 @@
     "scripts/active-memory.test.mjs"
   ],
   "check:browser": [
+    "scripts/revert-browser.test.mjs",
     "scripts/extension-ui-browser.test.mjs",
     "scripts/inline-rename-blur.test.mjs",
     "scripts/message-timestamps-browser.test.mjs",
@@ -93,6 +95,7 @@
     "scripts/workflow-browser.test.mjs",
     "scripts/conversation-reconcile-browser.test.mjs",
     "scripts/visual-defects-browser.test.mjs",
+    "scripts/session-state-animation-browser.test.mjs",
     "scripts/agent-vis-card-browser.test.mjs",
     "scripts/queue-dock.test.mjs",
     "scripts/md-render-browser.test.mjs",