openmausbot 0.1.95 → 0.1.97

package/dist-server/server/drivers/pi.js

@@ -40,6 +40,12 @@ const DRIVER_KIND = "piAgent";
 const PI_ARGS = ["--mode", "rpc", "--no-session"];
 const PI_MODEL_UPDATE_ARGS = ["update", "--models", "--no-approve"];
 const NODE_ENV_FLAG = { ELECTRON_RUN_AS_NODE: "1" };
+/** omp's RPC transport caps one frame at 1 MiB and only chunks oversized
+ *  frames after the client negotiates protocol 2. Sent before the first
+ *  command on every spawn: stdin order guarantees the declaration lands
+ *  before the response to that command is encoded, and vanilla pi has no
+ *  handshake frame to wait for, so nobody gates on a reply. */
+const PI_NEGOTIATE_FRAME = { id: "negotiate", type: "negotiate_protocol", protocolVersion: 2 };
 /** After this many bare turns on one pi session the full prompt rides
  * again even without a compaction event: any history rewrite the events
  * miss (an older pi, a missed line) still loses at most this many turns
@@ -135,12 +141,26 @@ export function buildMcpServers(turn) {
     }
     return Object.keys(servers).length ? servers : null;
 }
+/** One decoded frame → catalog, or null when it is not a successful
+ *  `get_available_models` response. Every option is `custom` (pi is BYOK)
+ *  and id is the `provider/modelId` composite the picker and `set_model`
+ *  both use. */
+function piCatalogFromFrame(frame, fallbackDefault) {
+    const res = frame;
+    if (res?.type !== "response" || res.command !== "get_available_models" || !res.success)
+        return null;
+    const options = [];
+    for (const m of res.data?.models ?? []) {
+        if (!m?.provider || !m?.id)
+            continue;
+        const id = `${m.provider}/${m.id}`;
+        options.push({ id, label: m.name ?? m.id, custom: true, provider: m.provider });
+    }
+    return { default: fallbackDefault || (options[0]?.id ?? ""), options };
+}
 /** Pure parser: turn a `get_available_models` stdout blob into a catalog.
- *  Every option is `custom` (pi is BYOK) and id is the `provider/modelId`
- *  composite the picker and `set_model` both use. Exported for the test. */
+ *  Exported for the test. */
 export function parsePiCatalog(stdout, fallbackDefault = "") {
-    const options = [];
-    let def = fallbackDefault;
     for (const line of stdout.split("\n")) {
         if (!line.trim())
             continue;
@@ -151,20 +171,142 @@ export function parsePiCatalog(stdout, fallbackDefault = "") {
         catch {
             continue;
         }
-        const res = msg;
-        if (res?.type !== "response" || res.command !== "get_available_models" || !res.success)
-            continue;
-        for (const m of res.data?.models ?? []) {
-            if (!m?.provider || !m?.id)
-                continue;
-            const id = `${m.provider}/${m.id}`;
-            options.push({ id, label: m.name ?? m.id, custom: true, provider: m.provider });
+        const catalog = piCatalogFromFrame(msg, fallbackDefault);
+        if (catalog)
+            return catalog;
+    }
+    return { default: fallbackDefault, options: [] };
+}
+/** omp's RPC v2 splits any frame larger than 1 MiB into base64 `rpc_chunk`
+ *  pieces: one `chunkId`/`count`/`byteLength` for the whole frame, a
+ *  sequential `index`, and `data` carrying one piece. Reassembles one
+ *  logical frame at a time; any inconsistency drops the partial sequence so
+ *  a corrupt stream can never feed a half-built frame to the parser.
+ *  Exported for the test. */
+export class PiRpcChunks {
+    /** omp's advertised cap on one reassembled frame. */
+    static MAX_BYTES = 64 * 1024 * 1024;
+    /** omp's cap on one decoded piece, which also bounds the piece count. */
+    static MAX_PIECE_BYTES = 256 * 1024;
+    static MAX_COUNT = PiRpcChunks.MAX_BYTES / PiRpcChunks.MAX_PIECE_BYTES;
+    chunkId = null;
+    count = 0;
+    byteLength = 0;
+    bytes = 0;
+    parts = [];
+    /** Feed one `rpc_chunk`; returns the reassembled frame when the last
+     *  piece arrives, or null while the sequence is incomplete or broken. */
+    accept(message) {
+        const { chunkId, index, count, byteLength, data } = message;
+        if (typeof chunkId !== "string" || chunkId.length === 0 || typeof data !== "string" ||
+            // Bound the base64 before decoding it, so an oversized piece is
+            // rejected without allocating its bytes.
+            data.length === 0 || data.length > Math.ceil(PiRpcChunks.MAX_PIECE_BYTES / 3) * 4 ||
+            !Number.isInteger(index) || !Number.isInteger(count) || !Number.isInteger(byteLength) ||
+            index < 0 || count < 2 || count > PiRpcChunks.MAX_COUNT ||
+            index >= count ||
+            byteLength < 0 || byteLength > PiRpcChunks.MAX_BYTES) {
+            this.reset();
+            return null;
+        }
+        if (chunkId !== this.chunkId) {
+            // A new sequence may only start at index 0; a different chunkId
+            // mid-sequence means the previous one can never complete.
+            if (index !== 0) {
+                this.reset();
+                return null;
+            }
+            this.chunkId = chunkId;
+            this.count = count;
+            this.byteLength = byteLength;
+            this.parts = [];
+            this.bytes = 0;
+        }
+        else if (count !== this.count || byteLength !== this.byteLength) {
+            this.reset();
+            return null;
+        }
+        const part = Buffer.from(data, "base64");
+        // Every piece must carry bytes: an empty one would let a sequence grow
+        // `parts` without ever approaching `byteLength`.
+        if (index !== this.parts.length || part.length === 0 || part.length > PiRpcChunks.MAX_PIECE_BYTES ||
+            this.bytes + part.length > this.byteLength) {
+            this.reset();
+            return null;
+        }
+        this.parts.push(part);
+        this.bytes += part.length;
+        if (this.parts.length < this.count)
+            return null;
+        const complete = this.bytes === this.byteLength;
+        const text = Buffer.concat(this.parts).toString("utf8");
+        this.reset();
+        if (!complete)
+            return null;
+        try {
+            const frame = JSON.parse(text);
+            return frame && typeof frame === "object" && !Array.isArray(frame)
+                ? frame
+                : null;
+        }
+        catch {
+            return null;
         }
-        break;
     }
-    if (!def && options.length)
-        def = options[0].id;
-    return { default: def, options };
+    reset() {
+        this.chunkId = null;
+        this.count = 0;
+        this.byteLength = 0;
+        this.bytes = 0;
+        this.parts = [];
+    }
+}
+/** Decode one pi stdout line: a plain JSON frame, or one piece of an
+ *  `rpc_chunk` sequence (omp's protocol v2) with the reassembled frame
+ *  returned once complete. Non-JSON lines, scalars and broken sequences
+ *  resolve null and are skipped. Exported for the test. */
+export function decodePiFrame(line, chunks) {
+    let parsed;
+    try {
+        parsed = JSON.parse(line);
+    }
+    catch {
+        return null;
+    }
+    if (!parsed || typeof parsed !== "object" || Array.isArray(parsed))
+        return null;
+    const frame = parsed;
+    return frame.type === "rpc_chunk" ? chunks.accept(frame) : frame;
+}
+/** Longest stdout line a reader buffers: omp's cap on one whole frame. */
+const PI_MAX_LINE = PiRpcChunks.MAX_BYTES;
+/** Split a pi child's stdout into non-blank lines for `onLine`, which
+ *  returns true to stop reading. A line longer than PI_MAX_LINE is dropped
+ *  through its newline instead of growing the buffer without bound.
+ *  Exported for the test. */
+export function piLineReader(onLine) {
+    let buf = "";
+    let dropping = false;
+    return (chunk) => {
+        buf += chunk;
+        let nl;
+        while ((nl = buf.indexOf("\n")) !== -1) {
+            const line = buf.slice(0, nl);
+            buf = buf.slice(nl + 1);
+            if (dropping) {
+                dropping = false;
+                continue;
+            }
+            if (line.length > PI_MAX_LINE || !line.trim())
+                continue;
+            if (onLine(line))
+                return;
+        }
+        if (buf.length > PI_MAX_LINE) {
+            buf = "";
+            dropping = true;
+        }
+    };
 }
 /** Split a picker id into pi's `{provider, modelId}`. Accepts both the
  *  native `provider/modelId` composite and a live-host `host::model`
@@ -306,7 +448,6 @@ function readPiDefaultModel(env) {
 export async function fetchPiModels(cli, env) {
     const child = spawnCli(cli, PI_ARGS, { stdio: ["pipe", "pipe", "pipe"], env });
     return new Promise((resolve) => {
-        let buf = "";
         let done = false;
         const fallbackDefault = readPiDefaultModel(env);
         const finish = (catalog) => {
@@ -323,26 +464,20 @@ export async function fetchPiModels(cli, env) {
         };
         const timer = setTimeout(() => finish({ default: "", options: [] }), 15_000);
         timer.unref?.();
+        const chunks = new PiRpcChunks();
         child.stdout.setEncoding("utf8");
-        child.stdout.on("data", (chunk) => {
-            buf += chunk;
-            let nl;
-            while ((nl = buf.indexOf("\n")) !== -1) {
-                const line = buf.slice(0, nl);
-                buf = buf.slice(nl + 1);
-                if (!line.trim())
-                    continue;
-                const parsed = parsePiCatalog(line + "\n", fallbackDefault);
-                if (parsed.options.length || line.includes('"get_available_models"')) {
-                    clearTimeout(timer);
-                    finish(parsed);
-                    return;
-                }
-            }
-        });
+        child.stdout.on("data", piLineReader((line) => {
+            const frame = decodePiFrame(line, chunks);
+            if (frame?.command !== "get_available_models")
+                return false;
+            clearTimeout(timer);
+            finish(piCatalogFromFrame(frame, fallbackDefault) ?? { default: fallbackDefault, options: [] });
+            return true;
+        }));
         child.on("error", () => finish({ default: "", options: [] }));
         child.on("close", () => finish({ default: "", options: [] }));
         try {
+            child.stdin.write(`${JSON.stringify(PI_NEGOTIATE_FRAME)}\n`);
             child.stdin.write(JSON.stringify({ id: "catalog", type: "get_available_models" }) + "\n");
         }
         catch {
@@ -542,7 +677,6 @@ export const PiDriver = {
                     throw err;
                 }
             })();
-            let buf = "";
             let assistantText = "";
             // set when a compaction event arrives this turn; gates the receipt
             // write below so a compacted-around delivery is never claimed
@@ -575,6 +709,11 @@ export const PiDriver = {
                 appendNative(threadId, { dir: "out", source: "pi.rpc", msg: piNativeLogMessage(obj) });
                 child.stdin.write(JSON.stringify(obj) + "\n");
             };
+            // Declare protocol 2 on the same stdin before the first command, so an
+            // omp-style runtime chunks any oversized frame it sends back. Vanilla
+            // pi refuses the unknown command; no waiter is keyed for the reply,
+            // so either answer is ignored.
+            send(PI_NEGOTIATE_FRAME);
             /** Emit buffered assistant text as its own item, then clear it. */
             const flushAssistantText = () => {
                 const text = assistantText;
@@ -911,23 +1050,19 @@ export const PiDriver = {
                         return;
                 }
             };
+            const chunks = new PiRpcChunks();
             child.stdout.setEncoding("utf8");
-            child.stdout.on("data", (chunk) => {
-                buf += chunk;
-                let nl;
-                while ((nl = buf.indexOf("\n")) !== -1) {
-                    const line = buf.slice(0, nl);
-                    buf = buf.slice(nl + 1);
-                    if (!line.trim())
-                        continue;
-                    try {
-                        onEvent(JSON.parse(line));
-                    }
-                    catch {
-                        /* skip non-JSON line */
-                    }
+            child.stdout.on("data", piLineReader((line) => {
+                const frame = decodePiFrame(line, chunks);
+                if (!frame)
+                    return;
+                try {
+                    onEvent(frame);
                 }
-            });
+                catch {
+                    /* skip a frame the event handler can't consume */
+                }
+            }));
             child.on("error", (err) => {
                 const fail = describeSpawnFailure(err, config.cli);
                 rejectWaiters(new Error(fail.message));

package/dist-server/server/drivers/prompt-split.js

@@ -1,9 +1,9 @@
 // The stable/volatile prompt split, shared by the drivers that deliver it.
 // The stable half is everything that must stay byte-identical for a
 // provider's cached prefix (or a spawned CLI's session contract) to
-// survive; the volatile half (memory, mentions, outstanding teammate
-// work, recent work) legitimately changes mid-conversation and reaches
-// the model inside the turn that changed it, after the cacheable prefix.
+// survive; the volatile half (the sections in VOLATILE_SECTIONS,
+// system-prompt.ts) legitimately changes mid-conversation and reaches the
+// model inside the turn that changed it, after the cacheable prefix.
 import { createHash } from "node:crypto";
 import { mkdirSync, readFileSync, rmSync } from "node:fs";
 import { join } from "node:path";
@@ -20,7 +20,7 @@ export function promptHalves(turn) {
     return { stable: systemStable, volatile: systemVolatile };
 }
 export const VOLATILE_CONTEXT_NOTE_PREFIX = "Context from OpenMausBot updated since this conversation started; it replaces any earlier copy:";
-export const VOLATILE_CONTEXT_CLEARED_NOTE = "The OpenMausBot context notes from earlier in this conversation (memory, mentions, outstanding teammate work) have been cleared; the standing instructions still apply.";
+export const VOLATILE_CONTEXT_CLEARED_NOTE = "The OpenMausBot context notes from earlier in this conversation have been cleared; the standing instructions still apply.";
 /** The labelled block that carries a changed volatile half inside a user
  * turn. A half that is empty and always was needs no note; one that was
  * cleared announces the removal so the model stops relying on it. */

package/dist-server/server/harness/bus.js

@@ -4,6 +4,13 @@
 // a per-thread canonical NDJSON log (the debugging trick both upstream and
 // agentcal lean on), and delivered to subscribers (the SSE endpoint and
 // the server-side message folder).
+//
+// Streamed text is merged here, once, for every engine on every kind of
+// install: a provider sends a reply as hundreds of small text deltas, and
+// each would otherwise be its own log line, listener call and SSE frame. The
+// bus holds a thread's text for at most DELTA_MERGE_MS and publishes it as
+// one delta, sooner when anything else happens on that thread, so the order
+// of events never changes.
 import { appendFileSync } from "node:fs";
 import { join } from "node:path";
 import { EVENTS_DIR } from "../config.js";
@@ -11,10 +18,19 @@ import { redactSecrets } from "../redact.js";
 import { capThreadLog, currentThreadLogCap } from "../thread-log-rotation.js";
 import { newId } from "../contracts.js";
 const INCOMPLETE_LOG_MESSAGE = "Canonical event history is incomplete: OpenMausBot could not write one or more events to disk. Live updates will continue.";
+/** How long a thread's streamed text waits to be merged with what follows. */
+const DELTA_MERGE_MS = 50;
+/** Two deltas are one stream when only their text, id and time differ. */
+function sameStream(a, b) {
+    return a.provider === b.provider && a.providerInstanceId === b.providerInstanceId && a.turnId === b.turnId &&
+        a.itemId === b.itemId && a.streamKind === b.streamKind && a.synthetic === b.synthetic;
+}
 export class EventBus {
     listeners = new Set();
     unsubscribes = new Map();
     pendingLogWarnings = new Map();
+    /** Per thread: the streamed text not yet published, and when it goes. */
+    pendingText = new Map();
     appendLog;
     constructor(appendLog = appendFileSync) {
         this.appendLog = appendLog;
@@ -35,6 +51,38 @@ export class EventBus {
         }
     }
     publish(event) {
+        const pending = this.pendingText.get(event.threadId);
+        if (event.type === "content.delta") {
+            if (pending && sameStream(pending.event, event)) {
+                pending.event = { ...pending.event, delta: pending.event.delta + event.delta };
+                return;
+            }
+            if (pending)
+                this.flushThread(event.threadId);
+            const timer = setTimeout(() => this.flushThread(event.threadId), DELTA_MERGE_MS);
+            timer.unref?.();
+            this.pendingText.set(event.threadId, { event, timer });
+            return;
+        }
+        if (pending)
+            this.flushThread(event.threadId);
+        this.write(event);
+    }
+    /** Publish every thread's waiting text now: on detach, and as the server exits. */
+    flush() {
+        for (const threadId of Array.from(this.pendingText.keys()))
+            this.flushThread(threadId);
+    }
+    flushThread(threadId) {
+        const pending = this.pendingText.get(threadId);
+        if (!pending)
+            return;
+        // gone from the map before delivery: a listener may publish on this thread
+        this.pendingText.delete(threadId);
+        clearTimeout(pending.timer);
+        this.write(pending.event);
+    }
+    write(event) {
         const pendingWarning = this.pendingLogWarnings.get(event.threadId);
         const persistedEvents = pendingWarning ? [pendingWarning, redactSecrets(event)] : [redactSecrets(event)];
         try {
@@ -91,5 +139,6 @@ export class EventBus {
     detach(instanceId) {
         this.unsubscribes.get(instanceId)?.();
         this.unsubscribes.delete(instanceId);
+        this.flush();
     }
 }

package/dist-server/server/harness-mcp-proxy.js

@@ -13,7 +13,7 @@ const RECOVERY = {
     browser: " This failure does not establish that all browsers are unavailable. Inspect available connections with select_computer if that tool is present. Keep the requested computer and account; do not bypass a permission refusal or human takeover, and do not repeat an uncertain action without checking its result.",
     computer: " Keep working on the assigned cloud computer only; do not bypass a person's control of it, and take a fresh screenshot before repeating an action whose result is uncertain.",
 };
-export function parseHarnessMcpKind(value) {
+function parseHarnessMcpKind(value) {
     return value === "browser" || value === "computer" ? value : null;
 }
 function failure(id, method, message, code = -32603) {