@agenthippo-ai/agenthippo 1.110.9 → 1.110.19

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

@@ -1,249 +0,0 @@
-"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));
-    }
-}

package/out/test/runtime.test.js

@@ -1,349 +0,0 @@
-"use strict";
-/*---------------------------------------------------------------------------------------------
- *  Copyright (c) AgentHippo.ai. All rights reserved.
- *--------------------------------------------------------------------------------------------*/
-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 path = __importStar(require("path"));
-const os = __importStar(require("os"));
-const fs_1 = require("fs");
-const interfaces_1 = require("../runtime/interfaces");
-// =============================================================================
-// Logger Tests
-// =============================================================================
-suite('Runtime Interfaces - Logger', () => {
-    test('ConsoleLogger has all required methods', () => {
-        const logger = new interfaces_1.ConsoleLogger('[Test]');
-        assert.strictEqual(typeof logger.debug, 'function');
-        assert.strictEqual(typeof logger.info, 'function');
-        assert.strictEqual(typeof logger.warn, 'function');
-        assert.strictEqual(typeof logger.error, 'function');
-    });
-    test('NoOpLogger has all required methods', () => {
-        const logger = new interfaces_1.NoOpLogger();
-        // Should not throw
-        logger.debug('test');
-        logger.info('test');
-        logger.warn('test');
-        logger.error('test');
-        logger.error('test', new Error('test'));
-    });
-});
-// =============================================================================
-// Permission Handler Tests
-// =============================================================================
-suite('Runtime Interfaces - PermissionHandler', () => {
-    test('AutoApprovePermissionHandler always allows', async () => {
-        const handler = new interfaces_1.AutoApprovePermissionHandler();
-        const result = await handler.requestPermission({
-            toolName: 'Bash',
-            toolInput: { command: 'ls' },
-        });
-        assert.deepStrictEqual(result, { behavior: 'allow' });
-    });
-    test('AutoDenyPermissionHandler always denies', async () => {
-        const handler = new interfaces_1.AutoDenyPermissionHandler();
-        const result = await handler.requestPermission({
-            toolName: 'Bash',
-            toolInput: { command: 'rm -rf /' },
-        });
-        assert.strictEqual(result.behavior, 'deny');
-    });
-    test('AutoDenyPermissionHandler uses custom message', async () => {
-        const handler = new interfaces_1.AutoDenyPermissionHandler('Custom deny message');
-        const result = await handler.requestPermission({ toolName: 'Write' });
-        assert.strictEqual(result.behavior, 'deny');
-        if (result.behavior === 'deny') {
-            assert.strictEqual(result.message, 'Custom deny message');
-        }
-    });
-});
-// =============================================================================
-// Edit Tracker Tests
-// =============================================================================
-suite('Runtime Interfaces - EditTracker', () => {
-    test('NoOpEditTracker startTracking returns undefined', async () => {
-        const tracker = new interfaces_1.NoOpEditTracker();
-        const result = await tracker.startTracking('session-1', ['/path/to/file.ts']);
-        assert.strictEqual(result, undefined);
-    });
-    test('NoOpEditTracker stopTracking does not throw', async () => {
-        const tracker = new interfaces_1.NoOpEditTracker();
-        // Should not throw
-        await tracker.stopTracking('session-1', 123);
-    });
-    test('NoOpEditTracker applyEdit does not throw', async () => {
-        const tracker = new interfaces_1.NoOpEditTracker();
-        // Should not throw
-        await tracker.applyEdit('session-1', '/path/to/file.ts', 'content', true);
-    });
-});
-// =============================================================================
-// Session Store Tests
-// =============================================================================
-suite('Runtime Interfaces - SessionStore', () => {
-    test('MemorySessionStore get/set works', async () => {
-        const store = new interfaces_1.MemorySessionStore();
-        // Initially undefined
-        assert.strictEqual(store.get('key1'), undefined);
-        // Set and get
-        await store.set('key1', { foo: 'bar' });
-        assert.deepStrictEqual(store.get('key1'), { foo: 'bar' });
-        // Overwrite
-        await store.set('key1', { foo: 'baz' });
-        assert.deepStrictEqual(store.get('key1'), { foo: 'baz' });
-    });
-    test('MemorySessionStore clear removes all values', async () => {
-        const store = new interfaces_1.MemorySessionStore();
-        await store.set('key1', 'value1');
-        await store.set('key2', 'value2');
-        assert.strictEqual(store.get('key1'), 'value1');
-        assert.strictEqual(store.get('key2'), 'value2');
-        store.clear();
-        assert.strictEqual(store.get('key1'), undefined);
-        assert.strictEqual(store.get('key2'), undefined);
-    });
-    test('MemorySessionStore supports different value types', async () => {
-        const store = new interfaces_1.MemorySessionStore();
-        await store.set('string', 'hello');
-        await store.set('number', 42);
-        await store.set('boolean', true);
-        await store.set('object', { nested: { value: 123 } });
-        await store.set('array', [1, 2, 3]);
-        assert.strictEqual(store.get('string'), 'hello');
-        assert.strictEqual(store.get('number'), 42);
-        assert.strictEqual(store.get('boolean'), true);
-        assert.deepStrictEqual(store.get('object'), { nested: { value: 123 } });
-        assert.deepStrictEqual(store.get('array'), [1, 2, 3]);
-    });
-});
-// =============================================================================
-// FileSessionStore Tests
-// =============================================================================
-suite('Runtime Interfaces - FileSessionStore', () => {
-    let tempDir;
-    let testFilePath;
-    setup(async () => {
-        tempDir = await fs_1.promises.mkdtemp(path.join(os.tmpdir(), 'agentide-test-'));
-        testFilePath = path.join(tempDir, 'sessions.json');
-    });
-    teardown(async () => {
-        try {
-            await fs_1.promises.rm(tempDir, { recursive: true, force: true });
-        }
-        catch {
-            // Ignore cleanup errors
-        }
-    });
-    test('FileSessionStore get/set works', async () => {
-        const store = new interfaces_1.FileSessionStore(testFilePath);
-        await store.load();
-        // Initially undefined
-        assert.strictEqual(store.get('key1'), undefined);
-        // Set and get
-        await store.set('key1', { foo: 'bar' });
-        assert.deepStrictEqual(store.get('key1'), { foo: 'bar' });
-        // Overwrite
-        await store.set('key1', { foo: 'baz' });
-        assert.deepStrictEqual(store.get('key1'), { foo: 'baz' });
-    });
-    test('FileSessionStore persists to disk', async () => {
-        // Write with first store instance
-        const store1 = new interfaces_1.FileSessionStore(testFilePath);
-        await store1.load();
-        await store1.set('persistent', { data: 'survives' });
-        // Read with new store instance
-        const store2 = new interfaces_1.FileSessionStore(testFilePath);
-        await store2.load();
-        assert.deepStrictEqual(store2.get('persistent'), { data: 'survives' });
-    });
-    test('FileSessionStore handles missing file gracefully', async () => {
-        const nonExistentPath = path.join(tempDir, 'does-not-exist.json');
-        const store = new interfaces_1.FileSessionStore(nonExistentPath);
-        await store.load(); // Should not throw
-        assert.strictEqual(store.get('anything'), undefined);
-    });
-    test('FileSessionStore clear removes all values', async () => {
-        const store = new interfaces_1.FileSessionStore(testFilePath);
-        await store.load();
-        await store.set('key1', 'value1');
-        await store.set('key2', 'value2');
-        assert.strictEqual(store.get('key1'), 'value1');
-        assert.strictEqual(store.get('key2'), 'value2');
-        await store.clear();
-        assert.strictEqual(store.get('key1'), undefined);
-        assert.strictEqual(store.get('key2'), undefined);
-        // Verify cleared state persists
-        const store2 = new interfaces_1.FileSessionStore(testFilePath);
-        await store2.load();
-        assert.strictEqual(store2.get('key1'), undefined);
-    });
-    test('FileSessionStore load is idempotent', async () => {
-        const store = new interfaces_1.FileSessionStore(testFilePath);
-        await store.load();
-        await store.set('key', 'original');
-        // Calling load again should not reset state
-        await store.load();
-        assert.strictEqual(store.get('key'), 'original');
-    });
-});
-// =============================================================================
-// DirectorySessionStore Tests (one file per session entry)
-// =============================================================================
-suite('Runtime Interfaces - DirectorySessionStore', () => {
-    // session.ts persists the whole map under a single record-valued logical key.
-    const KEY = 'agentide.providerSessions.v1';
-    let tempDir;
-    let dir;
-    setup(async () => {
-        tempDir = await fs_1.promises.mkdtemp(path.join(os.tmpdir(), 'agentide-dirstore-'));
-        dir = path.join(tempDir, 'provider-sessions');
-    });
-    teardown(async () => {
-        try {
-            await fs_1.promises.rm(tempDir, { recursive: true, force: true });
-        }
-        catch {
-            // Ignore cleanup errors
-        }
-    });
-    const jsonFiles = async () => (await fs_1.promises.readdir(dir)).filter((f) => f.endsWith('.json'));
-    test('stores each entry in its own file and round-trips the merged map', async () => {
-        const store = new interfaces_1.DirectorySessionStore(dir);
-        await store.set(KEY, { a: { id: 1 }, b: { id: 2 } });
-        assert.strictEqual((await jsonFiles()).length, 2);
-        // A fresh instance loads the sharded files back into the merged map.
-        const store2 = new interfaces_1.DirectorySessionStore(dir);
-        assert.deepStrictEqual(store2.get(KEY), { a: { id: 1 }, b: { id: 2 } });
-    });
-    test('writes only changed entries and deletes removed ones', async () => {
-        const store = new interfaces_1.DirectorySessionStore(dir);
-        await store.set(KEY, { a: { id: 1 }, b: { id: 2 } });
-        // Drop b (as a prune would), keep a.
-        await store.set(KEY, { a: { id: 1 } });
-        assert.strictEqual((await jsonFiles()).length, 1);
-        const store2 = new interfaces_1.DirectorySessionStore(dir);
-        assert.deepStrictEqual(store2.get(KEY), { a: { id: 1 } });
-    });
-    test('migrates a legacy single-file store on first load', async () => {
-        // Legacy FileSessionStore layout: { <logicalKey>: { <entryKey>: value } }
-        await fs_1.promises.mkdir(tempDir, { recursive: true });
-        await fs_1.promises.writeFile(`${dir}.json`, JSON.stringify({ [KEY]: { old: { id: 9 } } }), 'utf-8');
-        const store = new interfaces_1.DirectorySessionStore(dir);
-        assert.deepStrictEqual(store.get(KEY), { old: { id: 9 } });
-        // A subsequent set persists the imported entries as shard files.
-        await store.set(KEY, { old: { id: 9 }, fresh: { id: 10 } });
-        assert.strictEqual((await jsonFiles()).length, 2);
-    });
-});
-// =============================================================================
-// Config Provider Tests
-// =============================================================================
-suite('Runtime Interfaces - ConfigProvider', () => {
-    test('StaticConfigProvider get returns configured values', () => {
-        const provider = new interfaces_1.StaticConfigProvider({
-            'agentide.claude.maxThinkingTokens': 2048,
-            'agentide.permissions.fileAccess': 'workspace-write',
-        });
-        assert.strictEqual(provider.get('agentide', 'claude.maxThinkingTokens'), 2048);
-        assert.strictEqual(provider.get('agentide', 'permissions.fileAccess'), 'workspace-write');
-    });
-    test('StaticConfigProvider get returns default for missing key', () => {
-        const provider = new interfaces_1.StaticConfigProvider({});
-        assert.strictEqual(provider.get('agentide', 'missing.key'), undefined);
-        assert.strictEqual(provider.get('agentide', 'missing.key', 'default'), 'default');
-    });
-    test('StaticConfigProvider getCustomProviders returns configured providers', () => {
-        const customProviders = {
-            'openrouter': {
-                baseUrl: 'https://openrouter.ai/api/v1',
-                overrideOpenAIBaseUrl: 'https://openrouter.ai/api/v1',
-            },
-        };
-        const provider = new interfaces_1.StaticConfigProvider({}, customProviders);
-        const result = provider.getCustomProviders();
-        assert.deepStrictEqual(result, customProviders);
-    });
-    test('StaticConfigProvider getEngineSettings returns configured settings', () => {
-        const engineSettings = {
-            claudeMaxThinkingTokens: 4096,
-            claudeCheapModel: 'claude-haiku-4-5-20251001',
-        };
-        const provider = new interfaces_1.StaticConfigProvider({}, {}, engineSettings);
-        const result = provider.getEngineSettings();
-        assert.deepStrictEqual(result, engineSettings);
-    });
-    test('StaticConfigProvider returns empty defaults', () => {
-        const provider = new interfaces_1.StaticConfigProvider();
-        assert.deepStrictEqual(provider.getCustomProviders(), {});
-        assert.deepStrictEqual(provider.getEngineSettings(), {});
-    });
-});
-// =============================================================================
-// Integration Tests
-// =============================================================================
-suite('Runtime Interfaces - Integration', () => {
-    test('MemorySessionStore can be used for eval mode (fresh state)', async () => {
-        const store = new interfaces_1.MemorySessionStore();
-        // Simulate session 1
-        await store.set('session-1', { threadId: 'abc123' });
-        // Clear for fresh state (eval mode)
-        store.clear();
-        // Session should be gone
-        assert.strictEqual(store.get('session-1'), undefined);
-    });
-    test('AutoApprovePermissionHandler is suitable for eval mode', async () => {
-        const handler = new interfaces_1.AutoApprovePermissionHandler();
-        // All permissions should be auto-approved
-        const dangerous = await handler.requestPermission({ toolName: 'Bash', toolInput: { command: 'rm -rf /' } });
-        assert.strictEqual(dangerous.behavior, 'allow');
-        const write = await handler.requestPermission({ toolName: 'Write', toolInput: { path: '/etc/passwd' } });
-        assert.strictEqual(write.behavior, 'allow');
-    });
-    test('StaticConfigProvider can override VS Code settings', () => {
-        // This simulates eval mode where we might want different settings
-        const evalConfig = new interfaces_1.StaticConfigProvider({
-            'agentide.permissions.fileAccess': 'full',
-        }, {}, {
-            claudeMaxThinkingTokens: 8192,
-            claudeCheapModel: 'claude-haiku-4-5-20251001',
-        });
-        assert.strictEqual(evalConfig.get('agentide', 'permissions.fileAccess'), 'full');
-        assert.strictEqual(evalConfig.getEngineSettings().claudeMaxThinkingTokens, 8192);
-        assert.strictEqual(evalConfig.getEngineSettings().claudeCheapModel, 'claude-haiku-4-5-20251001');
-    });
-});