@nettee/beacon 0.4.0 → 0.4.1

package/dist/daemon/runtime/pi-rpc.d.ts

@@ -38,5 +38,19 @@ export declare class PiRuntimeError extends Error {
 }
 /** Collect thinking / reasoning blocks from an assistant message content array. */
 export declare function collectThinking(content: unknown[]): string;
+/**
+ * Read NDJSON frames from Pi stdout with a hard per-frame byte cap.
+ *
+ * Oversized frames (for example tool events carrying multi-MB stdout) are
+ * discarded through the next newline instead of failing the whole Run. Beacon
+ * only needs prompt responses, `message_end`, and `agent_settled`; intermediate
+ * tool frames are ignored anyway, and Pi already truncates tool output for the
+ * model. The cap still bounds parse/buffer memory — we never raise it here.
+ */
+export declare function createCappedNdjsonReader(maxFrameBytes: number, onFrame: (line: string) => void): {
+    push: (chunk: Buffer) => void;
+    close: () => void;
+    readonly skippedOversizedFrames: number;
+};
 export declare function runPiAgent(request: PiRunRequest, options?: PiRuntimeOptions): Promise<PiRunResult>;
 export {};

package/dist/daemon/runtime/pi-rpc.js

@@ -1,7 +1,6 @@
 import { spawn } from "node:child_process";
 import { chmod, mkdir } from "node:fs/promises";
 import { isAbsolute } from "node:path";
-import { createInterface } from "node:readline";
 import { fileURLToPath } from "node:url";
 import { assertRuntimeEnvironmentKey } from "../config/runtime-environment.js";
 export class PiRuntimeError extends Error {
@@ -155,6 +154,81 @@ async function stopProcess(child, terminateGraceMs) {
         });
     });
 }
+/**
+ * Read NDJSON frames from Pi stdout with a hard per-frame byte cap.
+ *
+ * Oversized frames (for example tool events carrying multi-MB stdout) are
+ * discarded through the next newline instead of failing the whole Run. Beacon
+ * only needs prompt responses, `message_end`, and `agent_settled`; intermediate
+ * tool frames are ignored anyway, and Pi already truncates tool output for the
+ * model. The cap still bounds parse/buffer memory — we never raise it here.
+ */
+export function createCappedNdjsonReader(maxFrameBytes, onFrame) {
+    if (!Number.isSafeInteger(maxFrameBytes) || maxFrameBytes <= 0) {
+        throw new Error("Pi RPC frame limit must be a positive integer");
+    }
+    const chunks = [];
+    let bufferedBytes = 0;
+    let discarding = false;
+    let closed = false;
+    let skippedOversizedFrames = 0;
+    const resetBuffer = () => {
+        chunks.length = 0;
+        bufferedBytes = 0;
+    };
+    const emitFrame = () => {
+        const line = Buffer.concat(chunks, bufferedBytes).toString("utf8");
+        resetBuffer();
+        onFrame(line);
+    };
+    const push = (chunk) => {
+        if (closed || chunk.length === 0)
+            return;
+        let offset = 0;
+        while (offset < chunk.length) {
+            if (discarding) {
+                const nl = chunk.indexOf(10, offset);
+                if (nl === -1)
+                    return;
+                discarding = false;
+                offset = nl + 1;
+                continue;
+            }
+            const nl = chunk.indexOf(10, offset);
+            const end = nl === -1 ? chunk.length : nl;
+            const pieceLen = end - offset;
+            if (bufferedBytes + pieceLen > maxFrameBytes) {
+                skippedOversizedFrames += 1;
+                resetBuffer();
+                if (nl === -1) {
+                    discarding = true;
+                    return;
+                }
+                offset = nl + 1;
+                continue;
+            }
+            if (pieceLen > 0) {
+                chunks.push(chunk.subarray(offset, end));
+                bufferedBytes += pieceLen;
+            }
+            if (nl === -1)
+                return;
+            emitFrame();
+            offset = nl + 1;
+        }
+    };
+    return {
+        push,
+        close: () => {
+            closed = true;
+            resetBuffer();
+            discarding = false;
+        },
+        get skippedOversizedFrames() {
+            return skippedOversizedFrames;
+        },
+    };
+}
 export async function runPiAgent(request, options = {}) {
     if (!request.prompt.trim())
         throw new Error("Pi Run prompt must not be empty");
@@ -199,11 +273,11 @@ export async function runPiAgent(request, options = {}) {
         env: buildPiEnvironment(request.outcome, options.environment, options.runtimeEnvironment),
         stdio: ["pipe", "pipe", "pipe"],
     });
-    const lines = createInterface({ input: child.stdout, crlfDelay: Infinity });
     let stderr = "";
     let finalMessage;
     let promptAccepted = false;
     let finished = false;
+    let frames;
     child.stderr.setEncoding("utf8");
     child.stderr.on("data", (chunk) => {
         stderr = (stderr + chunk).slice(-64 * 1024);
@@ -218,27 +292,7 @@ export async function runPiAgent(request, options = {}) {
                 reject(error);
             };
             const timer = setTimeout(() => fail(new PiRuntimeError("runtime_timeout", `Pi Run timed out after ${timeoutMs}ms${stderr.trim() ? `: ${stderr.trim()}` : ""}`)), timeoutMs);
-            let frameBytes = 0;
-            child.stdout.on("data", (chunk) => {
-                for (const byte of chunk) {
-                    if (byte === 10)
-                        frameBytes = 0;
-                    else
-                        frameBytes += 1;
-                    if (frameBytes > maxFrameBytes) {
-                        fail(new PiRuntimeError("runtime_protocol_error", `Pi RPC frame exceeds ${maxFrameBytes} bytes`));
-                        return;
-                    }
-                }
-            });
-            child.once("error", (error) => fail(new PiRuntimeError("runtime_spawn_failed", `Failed to start Pi: ${error.message}`, {
-                cause: error,
-            })));
-            child.once("exit", (code, signal) => {
-                if (!finished)
-                    fail(describeExit(code, signal, stderr));
-            });
-            lines.on("line", (line) => {
+            const handleFrame = (line) => {
                 if (finished)
                     return;
                 let value;
@@ -295,13 +349,24 @@ export async function runPiAgent(request, options = {}) {
                 catch (error) {
                     fail(error instanceof Error ? error : new Error(String(error)));
                 }
+            };
+            frames = createCappedNdjsonReader(maxFrameBytes, handleFrame);
+            child.stdout.on("data", (chunk) => {
+                frames?.push(chunk);
+            });
+            child.once("error", (error) => fail(new PiRuntimeError("runtime_spawn_failed", `Failed to start Pi: ${error.message}`, {
+                cause: error,
+            })));
+            child.once("exit", (code, signal) => {
+                if (!finished)
+                    fail(describeExit(code, signal, stderr));
             });
             child.stdin.on("error", (error) => fail(new PiRuntimeError("runtime_protocol_error", `Failed to write Pi RPC command: ${error.message}`, { cause: error })));
             child.stdin.write(`${JSON.stringify({ id: "run-prompt", type: "prompt", message: request.prompt })}\n`);
         });
     }
     finally {
-        lines.close();
+        frames?.close();
         await stopProcess(child, terminateGraceMs);
     }
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@nettee/beacon",
-  "version": "0.4.0",
+  "version": "0.4.1",
   "description": "A single-host bridge from messaging and schedules to isolated agent runs",
   "license": "Apache-2.0",
   "repository": {