@agenthippo-ai/agenthippo 0.2.3-dataplane → 1.110.9

package/out/test/runner-protocol.test.js

@@ -0,0 +1,249 @@
+"use strict";
+/*---------------------------------------------------------------------------------------------
+ *  Sandbox runner layer (PLAN/serve-v4-clean.md §3–§4).
+ *
+ *  Covers the three rules the design turns on, each of which is a bug if it regresses:
+ *   1. a turn settles on the TERMINAL frame, never on the streamed `done` (engines call done()
+ *      mid-run — the existing worker protocol separates them for exactly this reason);
+ *   2. `question` is one-way — no reverse RPC, so it can never wedge a turn;
+ *   3. no model credential crosses into the sandbox (invariant 1).
+ *--------------------------------------------------------------------------------------------*/
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+require("mocha");
+const assert = __importStar(require("assert"));
+const node_stream_1 = require("node:stream");
+const protocol_1 = require("../runner/protocol");
+const host_1 = require("../runner/host");
+const remoteEngine_1 = require("../runner/remoteEngine");
+/** Minimal options for tests — the fields under test are baseUrl/modelToken/apiKey only. */
+const WIRE_OPTS = {};
+suite('runner protocol', () => {
+    test('round-trips every frame kind', () => {
+        const frames = [
+            { type: 'ready' },
+            { type: 'result', id: 'r1', nativeSessionId: 'nsid-9' },
+            { type: 'failed', id: 'r2', message: 'boom' },
+            { type: 'text', delta: 'hi' },
+            { type: 'toolEnd', toolName: 't', toolCallId: 'c1', isError: true },
+            { type: 'question', payload: { questionId: 'q1', prompt: 'pick' } },
+        ];
+        for (const f of frames) {
+            assert.deepStrictEqual((0, protocol_1.parseRunnerFrame)((0, protocol_1.encodeRunnerFrame)(f).trim()), f, `round-trip ${f.type}`);
+        }
+        const client = { type: 'run', id: 'r1', message: 'go', options: WIRE_OPTS };
+        assert.deepStrictEqual((0, protocol_1.parseClientFrame)((0, protocol_1.encodeClientFrame)(client).trim()), client);
+        assert.deepStrictEqual((0, protocol_1.parseClientFrame)('{"type":"abort","id":"r1"}'), { type: 'abort', id: 'r1' });
+    });
+    test('malformed input is dropped, never thrown — the sandbox is untrusted toward serve', () => {
+        for (const bad of ['', 'not json', '[]', 'null', '{"type":"nope"}', '{"type":"result"}', '{"type":"run"}']) {
+            assert.strictEqual((0, protocol_1.parseRunnerFrame)(bad), undefined, `runner frame: ${bad}`);
+            assert.strictEqual((0, protocol_1.parseClientFrame)(bad), undefined, `client frame: ${bad}`);
+        }
+    });
+    test('terminal frames are exactly result/failed — done and error are NOT terminal', () => {
+        assert.ok((0, protocol_1.isTerminalFrame)({ type: 'result', id: 'r1' }));
+        assert.ok((0, protocol_1.isTerminalFrame)({ type: 'failed', id: 'r1', message: 'x' }));
+        assert.ok(!(0, protocol_1.isTerminalFrame)({ type: 'done' }), 'streamed done must not end a turn');
+        assert.ok(!(0, protocol_1.isTerminalFrame)({ type: 'error', message: 'x' }), 'streamed error must not end a turn');
+    });
+    test('splitFrames keeps partial lines for the next chunk', () => {
+        const a = (0, protocol_1.splitFrames)('{"type":"ready"}\n{"type":"do');
+        assert.deepStrictEqual(a.lines, ['{"type":"ready"}']);
+        assert.strictEqual(a.rest, '{"type":"do');
+        const b = (0, protocol_1.splitFrames)(a.rest + 'ne"}\n');
+        assert.deepStrictEqual(b.lines, ['{"type":"done"}']);
+        assert.strictEqual(b.rest, '');
+    });
+    test('toWireOptions drops apiKey and attaches the sandbox-scoped model token (invariant 1)', () => {
+        const wire = (0, protocol_1.toWireOptions)({ apiKey: 'sk-secret', model: 'gpt-5.5', workspace: '/w' }, { baseUrl: 'http://127.0.0.1:9099/v1', modelToken: 'sandbox-scoped' });
+        assert.ok(!('apiKey' in wire), 'apiKey must never cross the sandbox boundary');
+        assert.ok(!JSON.stringify(wire).includes('sk-secret'), 'no provider key anywhere in the frame');
+        assert.strictEqual(wire.baseUrl, 'http://127.0.0.1:9099/v1');
+        assert.strictEqual(wire.modelToken, 'sandbox-scoped');
+        assert.strictEqual(wire.model, 'gpt-5.5', 'non-secret options survive');
+    });
+});
+/** Wire a RemoteEngine to a runner host over two in-memory pipes — the `process` driver shape. */
+function pair(engine) {
+    const toRunner = new node_stream_1.PassThrough();
+    const toServe = new node_stream_1.PassThrough();
+    const host = (0, host_1.startRunnerHost)({
+        engine,
+        runtime: { logger: { info() { }, warn() { }, error() { }, debug() { } } },
+        input: toRunner,
+        output: { write: (c) => toServe.write(c) },
+        maintenanceIntervalMs: 60_000,
+    });
+    const remote = new remoteEngine_1.RemoteEngine({
+        id: 'test', displayName: 'Test',
+        channel: { input: toServe, output: { write: (c) => toRunner.write(c) } },
+    });
+    return { host, remote };
+}
+function recorder() {
+    const events = [];
+    const emitter = {
+        async thinking(d) { events.push(`thinking:${d}`); },
+        async text(d) { events.push(`text:${d}`); },
+        async toolStart(n) { events.push(`toolStart:${n}`); },
+        async toolEnd(n) { events.push(`toolEnd:${n}`); },
+        async progress(m) { events.push(`progress:${m}`); },
+        async question(p) { events.push(`question:${p.questionId}`); return { selected: [], freeText: null, declined: true }; },
+        async error(m) { events.push(`error:${m}`); },
+        async done() { events.push('done'); },
+    };
+    return { events, emitter };
+}
+const RUNTIME = { logger: { info() { }, warn() { }, error() { }, debug() { } } };
+suite('runner host ⇄ RemoteEngine', () => {
+    test('streams events through and settles on the terminal frame, not the mid-run done()', async () => {
+        let resolveEngine;
+        const engine = {
+            id: 'e', displayName: 'E',
+            async stream(_m, _o, emitter) {
+                await emitter.text('hello');
+                await emitter.done(); // engines call done() MID-RUN...
+                await new Promise((r) => { resolveEngine = r; }); // ...then keep working
+                await emitter.text('after-done');
+            },
+            onMaintenance() { }, dispose() { },
+        };
+        const { remote } = pair(engine);
+        const { events, emitter } = recorder();
+        let settled = false;
+        const turn = remote.stream('go', {}, emitter, RUNTIME).then(() => { settled = true; });
+        await waitFor(() => events.includes('done'));
+        assert.strictEqual(settled, false, 'streamed done must NOT settle the turn');
+        resolveEngine?.();
+        await turn;
+        assert.strictEqual(settled, true, 'turn settles once the engine returns (result frame)');
+        assert.deepStrictEqual(events, ['text:hello', 'done', 'text:after-done']);
+    });
+    test('engine failure rejects the turn with the runner message', async () => {
+        const engine = {
+            id: 'e', displayName: 'E',
+            async stream() { throw new Error('engine exploded'); },
+            onMaintenance() { }, dispose() { },
+        };
+        const { remote } = pair(engine);
+        const { emitter } = recorder();
+        await assert.rejects(remote.stream('go', {}, emitter, RUNTIME), /engine exploded/);
+    });
+    test('question is one-way: the runner answers declined locally and the turn never blocks', async () => {
+        let answer;
+        const engine = {
+            id: 'e', displayName: 'E',
+            async stream(_m, _o, emitter) {
+                // If this awaited a reverse RPC that never comes, the turn would hang — the
+                // deadlock class the design removes by construction.
+                answer = await emitter.question({ questionId: 'q1', prompt: 'pick one' });
+                await emitter.text('continued');
+            },
+            onMaintenance() { }, dispose() { },
+        };
+        const { remote } = pair(engine);
+        const { events, emitter } = recorder();
+        await remote.stream('go', {}, emitter, RUNTIME);
+        assert.deepStrictEqual(answer, { selected: [], freeText: null, declined: true }, 'runner answers declined in-sandbox, mirroring serve.ts and headless');
+        assert.ok(events.includes('question:q1'), 'question still forwarded to serve for visibility');
+        assert.ok(events.includes('text:continued'), 'the run continues past the question');
+    });
+    test('abort reaches the in-sandbox engine and settles the turn', async () => {
+        const engine = {
+            id: 'e', displayName: 'E',
+            async stream(_m, _o, _emitter, _rt, signal) {
+                await new Promise((_resolve, reject) => {
+                    if (signal?.aborted) {
+                        return reject(new Error('aborted'));
+                    }
+                    signal?.addEventListener('abort', () => reject(new Error('aborted')), { once: true });
+                });
+            },
+            onMaintenance() { }, dispose() { },
+        };
+        const { remote } = pair(engine);
+        const { emitter } = recorder();
+        const controller = new AbortController();
+        const turn = remote.stream('go', {}, emitter, RUNTIME, controller.signal);
+        setTimeout(() => controller.abort(), 20);
+        await assert.rejects(turn, /aborted/);
+    });
+    test('nativeSessionId rides the terminal frame — session resume across sandbox death', async () => {
+        const engine = {
+            id: 'e', displayName: 'E',
+            async stream(_m, _o, emitter) { await emitter.text('x'); },
+            onMaintenance() { }, dispose() { },
+        };
+        const frames = [];
+        const toRunner = new node_stream_1.PassThrough();
+        (0, host_1.startRunnerHost)({
+            engine, runtime: RUNTIME, input: toRunner,
+            output: { write: (c) => { frames.push(c.trim()); return true; } },
+            maintenanceIntervalMs: 60_000,
+        });
+        const runFrame = { type: 'run', id: 'r1', message: 'go', options: WIRE_OPTS };
+        toRunner.write((0, protocol_1.encodeClientFrame)(runFrame));
+        await waitFor(() => frames.some((f) => f.includes('"result"')));
+        assert.ok(frames[0].includes('"ready"'), 'runner announces ready before serving turns');
+        const terminal = frames.find((f) => f.includes('"result"'));
+        assert.ok(terminal.includes('"id":"r1"'), 'terminal carries the run id');
+    });
+    test('a dead channel fails in-flight turns instead of hanging them', async () => {
+        const toServe = new node_stream_1.PassThrough();
+        let closeChannel;
+        const remote = new remoteEngine_1.RemoteEngine({
+            id: 't', displayName: 'T',
+            channel: {
+                input: toServe,
+                output: { write: () => true },
+                closed: new Promise((resolve) => { closeChannel = resolve; }),
+            },
+        });
+        const { emitter } = recorder();
+        const turn = remote.stream('go', {}, emitter, RUNTIME);
+        setTimeout(() => closeChannel?.(), 20);
+        await assert.rejects(turn, /sandbox channel closed/);
+    });
+});
+async function waitFor(cond, timeoutMs = 2000) {
+    const start = Date.now();
+    while (!cond()) {
+        if (Date.now() - start > timeoutMs) {
+            throw new Error('timed out waiting for condition');
+        }
+        await new Promise((r) => setTimeout(r, 5));
+    }
+}