palaryn 0.1.0

package/dist/tests/unit/storage.test.js

@@ -0,0 +1,698 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const memory_1 = require("../../src/storage/memory");
+// ---------------------------------------------------------------------------
+// Helpers
+// ---------------------------------------------------------------------------
+function makeBudgetState(overrides = {}) {
+    return {
+        task_id: 'task-001',
+        workspace_id: 'ws-001',
+        actor_id: 'actor-001',
+        spent_usd: 0,
+        steps: 0,
+        started_at: new Date().toISOString(),
+        ...overrides,
+    };
+}
+function makeAuditEvent(overrides = {}) {
+    return {
+        event_id: 'evt-001',
+        event_type: 'TOOL_CALL_RECEIVED',
+        timestamp: new Date().toISOString(),
+        tool_call_id: 'tc-001',
+        task_id: 'task-001',
+        workspace_id: 'ws-001',
+        actor_id: 'actor-001',
+        tool_name: 'http_request',
+        metadata: {},
+        ...overrides,
+    };
+}
+function makeToolResult(overrides = {}) {
+    return {
+        tool_call_id: 'tc-001',
+        task_id: 'task-001',
+        status: 'ok',
+        policy: { decision: 'allow', reasons: [] },
+        dlp: { detected: [], redactions: [], severity: 'low' },
+        budget: { estimated_cost_usd: 0, spent_cost_usd_task: 0, remaining_cost_usd_task: 100 },
+        timing: { started_at: '2026-01-01T00:00:00.000Z', duration_ms: 10 },
+        ...overrides,
+    };
+}
+function makeApprovalRecord(overrides = {}) {
+    return {
+        approval_id: 'appr-001',
+        tool_call_id: 'tc-001',
+        task_id: 'task-001',
+        workspace_id: 'ws-001',
+        actor_id: 'actor-001',
+        tool_name: 'http.get',
+        tool_capability: 'read',
+        args_summary: '{}',
+        scope: 'global',
+        reason: 'test',
+        token_hash: 'hash-001',
+        status: 'pending',
+        created_at: new Date().toISOString(),
+        expires_at: new Date(Date.now() + 3600000).toISOString(),
+        ...overrides,
+    };
+}
+// ---------------------------------------------------------------------------
+// InMemoryBudgetStore
+// ---------------------------------------------------------------------------
+describe('InMemoryBudgetStore', () => {
+    let store;
+    beforeEach(() => {
+        store = new memory_1.InMemoryBudgetStore();
+    });
+    // -- get / set task states ------------------------------------------------
+    describe('get/set task states', () => {
+        it('returns undefined for a non-existent task', () => {
+            expect(store.getTaskState('missing')).toBeUndefined();
+        });
+        it('stores and retrieves a task state', () => {
+            const state = makeBudgetState({ task_id: 'task-100' });
+            store.setTaskState('task-100', state);
+            expect(store.getTaskState('task-100')).toEqual(state);
+        });
+        it('overwrites an existing task state', () => {
+            const original = makeBudgetState({ spent_usd: 0 });
+            store.setTaskState('task-100', original);
+            const updated = makeBudgetState({ spent_usd: 5.5 });
+            store.setTaskState('task-100', updated);
+            expect(store.getTaskState('task-100')?.spent_usd).toBe(5.5);
+        });
+        it('stores multiple independent task states', () => {
+            const s1 = makeBudgetState({ task_id: 'task-1', spent_usd: 1 });
+            const s2 = makeBudgetState({ task_id: 'task-2', spent_usd: 2 });
+            store.setTaskState('task-1', s1);
+            store.setTaskState('task-2', s2);
+            expect(store.getTaskState('task-1')?.spent_usd).toBe(1);
+            expect(store.getTaskState('task-2')?.spent_usd).toBe(2);
+        });
+    });
+    // -- getCounter -----------------------------------------------------------
+    describe('getCounter', () => {
+        it('returns 0 for a missing key', () => {
+            expect(store.getCounter('nonexistent-key')).toBe(0);
+        });
+        it('returns the current value after incrementing', () => {
+            store.incrementCounter('calls:actor-001', 1);
+            expect(store.getCounter('calls:actor-001')).toBe(1);
+        });
+    });
+    // -- incrementCounter -----------------------------------------------------
+    describe('incrementCounter', () => {
+        it('accumulates multiple increments', () => {
+            store.incrementCounter('cost:ws-001', 0.25);
+            store.incrementCounter('cost:ws-001', 0.75);
+            store.incrementCounter('cost:ws-001', 1.0);
+            expect(store.getCounter('cost:ws-001')).toBe(2.0);
+        });
+        it('handles separate keys independently', () => {
+            store.incrementCounter('a', 10);
+            store.incrementCounter('b', 20);
+            expect(store.getCounter('a')).toBe(10);
+            expect(store.getCounter('b')).toBe(20);
+        });
+        it('handles negative increments', () => {
+            store.incrementCounter('c', 10);
+            store.incrementCounter('c', -3);
+            expect(store.getCounter('c')).toBe(7);
+        });
+    });
+    // -- getRetryCount / incrementRetryCount ----------------------------------
+    describe('getRetryCount / incrementRetryCount', () => {
+        it('returns 0 for a never-retried tool call', () => {
+            expect(store.getRetryCount('tc-unknown')).toBe(0);
+        });
+        it('increments and returns the new count', () => {
+            const count = store.incrementRetryCount('tc-001');
+            expect(count).toBe(1);
+            expect(store.getRetryCount('tc-001')).toBe(1);
+        });
+        it('accumulates across multiple increments', () => {
+            store.incrementRetryCount('tc-001');
+            store.incrementRetryCount('tc-001');
+            const third = store.incrementRetryCount('tc-001');
+            expect(third).toBe(3);
+            expect(store.getRetryCount('tc-001')).toBe(3);
+        });
+        it('tracks different tool calls independently', () => {
+            store.incrementRetryCount('tc-A');
+            store.incrementRetryCount('tc-A');
+            store.incrementRetryCount('tc-B');
+            expect(store.getRetryCount('tc-A')).toBe(2);
+            expect(store.getRetryCount('tc-B')).toBe(1);
+        });
+    });
+    // -- reset ----------------------------------------------------------------
+    describe('reset()', () => {
+        it('clears all task states, counters, and retry counts', () => {
+            store.setTaskState('task-1', makeBudgetState());
+            store.incrementCounter('cost:ws-1', 5);
+            store.incrementRetryCount('tc-1');
+            store.reset();
+            expect(store.getTaskState('task-1')).toBeUndefined();
+            expect(store.getCounter('cost:ws-1')).toBe(0);
+            expect(store.getRetryCount('tc-1')).toBe(0);
+        });
+    });
+});
+// ---------------------------------------------------------------------------
+// InMemoryAuditStore
+// ---------------------------------------------------------------------------
+describe('InMemoryAuditStore', () => {
+    let store;
+    beforeEach(() => {
+        store = new memory_1.InMemoryAuditStore();
+    });
+    // -- append and getAll ----------------------------------------------------
+    describe('append and getAll', () => {
+        it('starts empty', () => {
+            expect(store.getAll()).toEqual([]);
+        });
+        it('appends events and returns them via getAll', () => {
+            const e1 = makeAuditEvent({ event_id: 'e1' });
+            const e2 = makeAuditEvent({ event_id: 'e2' });
+            store.append(e1);
+            store.append(e2);
+            const all = store.getAll();
+            expect(all).toHaveLength(2);
+            expect(all[0].event_id).toBe('e1');
+            expect(all[1].event_id).toBe('e2');
+        });
+        it('getAll returns a copy (not a reference to internal array)', () => {
+            store.append(makeAuditEvent({ event_id: 'e1' }));
+            const snapshot = store.getAll();
+            store.append(makeAuditEvent({ event_id: 'e2' }));
+            // The snapshot should still have only 1 event
+            expect(snapshot).toHaveLength(1);
+            expect(store.getAll()).toHaveLength(2);
+        });
+    });
+    // -- getByTaskId ----------------------------------------------------------
+    describe('getByTaskId', () => {
+        it('filters events by task_id', () => {
+            store.append(makeAuditEvent({ event_id: 'e1', task_id: 'task-A', timestamp: '2025-01-01T00:00:01Z' }));
+            store.append(makeAuditEvent({ event_id: 'e2', task_id: 'task-B', timestamp: '2025-01-01T00:00:02Z' }));
+            store.append(makeAuditEvent({ event_id: 'e3', task_id: 'task-A', timestamp: '2025-01-01T00:00:03Z' }));
+            const results = store.getByTaskId('task-A');
+            expect(results).toHaveLength(2);
+            expect(results.map(e => e.event_id)).toEqual(['e1', 'e3']);
+        });
+        it('returns empty array when no events match', () => {
+            store.append(makeAuditEvent({ task_id: 'task-X' }));
+            expect(store.getByTaskId('task-Z')).toEqual([]);
+        });
+        it('returns results sorted by timestamp', () => {
+            store.append(makeAuditEvent({ event_id: 'late', task_id: 'task-A', timestamp: '2025-01-01T00:00:05Z' }));
+            store.append(makeAuditEvent({ event_id: 'early', task_id: 'task-A', timestamp: '2025-01-01T00:00:01Z' }));
+            store.append(makeAuditEvent({ event_id: 'mid', task_id: 'task-A', timestamp: '2025-01-01T00:00:03Z' }));
+            const results = store.getByTaskId('task-A');
+            expect(results.map(e => e.event_id)).toEqual(['early', 'mid', 'late']);
+        });
+    });
+    // -- getByToolCallId ------------------------------------------------------
+    describe('getByToolCallId', () => {
+        it('filters events by tool_call_id', () => {
+            store.append(makeAuditEvent({ event_id: 'e1', tool_call_id: 'tc-A', timestamp: '2025-01-01T00:00:01Z' }));
+            store.append(makeAuditEvent({ event_id: 'e2', tool_call_id: 'tc-B', timestamp: '2025-01-01T00:00:02Z' }));
+            store.append(makeAuditEvent({ event_id: 'e3', tool_call_id: 'tc-A', timestamp: '2025-01-01T00:00:03Z' }));
+            const results = store.getByToolCallId('tc-A');
+            expect(results).toHaveLength(2);
+            expect(results.map(e => e.event_id)).toEqual(['e1', 'e3']);
+        });
+        it('returns empty array when no events match', () => {
+            expect(store.getByToolCallId('tc-nonexistent')).toEqual([]);
+        });
+        it('returns results sorted by timestamp', () => {
+            store.append(makeAuditEvent({ event_id: 'z', tool_call_id: 'tc-1', timestamp: '2025-06-01T00:00:00Z' }));
+            store.append(makeAuditEvent({ event_id: 'a', tool_call_id: 'tc-1', timestamp: '2025-01-01T00:00:00Z' }));
+            const results = store.getByToolCallId('tc-1');
+            expect(results.map(e => e.event_id)).toEqual(['a', 'z']);
+        });
+    });
+    // -- getByEventType -------------------------------------------------------
+    describe('getByEventType', () => {
+        it('filters events by event_type', () => {
+            store.append(makeAuditEvent({ event_id: 'e1', event_type: 'TOOL_CALL_RECEIVED' }));
+            store.append(makeAuditEvent({ event_id: 'e2', event_type: 'POLICY_DECIDED' }));
+            store.append(makeAuditEvent({ event_id: 'e3', event_type: 'TOOL_CALL_RECEIVED' }));
+            store.append(makeAuditEvent({ event_id: 'e4', event_type: 'DLP_SCANNED' }));
+            const results = store.getByEventType('TOOL_CALL_RECEIVED');
+            expect(results).toHaveLength(2);
+            expect(results.map(e => e.event_id)).toEqual(['e1', 'e3']);
+        });
+        it('returns empty array for an event type with no matches', () => {
+            store.append(makeAuditEvent({ event_type: 'TOOL_EXECUTED' }));
+            expect(store.getByEventType('INCIDENT_RAISED')).toEqual([]);
+        });
+        it('filters across all known event types', () => {
+            const types = [
+                'TOOL_CALL_RECEIVED',
+                'POLICY_DECIDED',
+                'DLP_SCANNED',
+                'BUDGET_CHECKED',
+                'TOOL_EXECUTED',
+                'TOOL_RESULT_RETURNED',
+                'APPROVAL_REQUESTED',
+                'APPROVAL_APPROVED',
+                'APPROVAL_DENIED',
+                'APPROVAL_EXPIRED',
+                'INCIDENT_RAISED',
+            ];
+            types.forEach((t, i) => {
+                store.append(makeAuditEvent({ event_id: `e${i}`, event_type: t }));
+            });
+            types.forEach((t, i) => {
+                const results = store.getByEventType(t);
+                expect(results).toHaveLength(1);
+                expect(results[0].event_id).toBe(`e${i}`);
+            });
+        });
+    });
+    // -- clear ----------------------------------------------------------------
+    describe('clear()', () => {
+        it('empties all events', () => {
+            store.append(makeAuditEvent({ event_id: 'e1' }));
+            store.append(makeAuditEvent({ event_id: 'e2' }));
+            expect(store.getAll()).toHaveLength(2);
+            store.clear();
+            expect(store.getAll()).toEqual([]);
+        });
+        it('allows new events after clearing', () => {
+            store.append(makeAuditEvent({ event_id: 'before' }));
+            store.clear();
+            store.append(makeAuditEvent({ event_id: 'after' }));
+            expect(store.getAll()).toHaveLength(1);
+            expect(store.getAll()[0].event_id).toBe('after');
+        });
+    });
+});
+// ---------------------------------------------------------------------------
+// InMemoryApprovalStore
+// ---------------------------------------------------------------------------
+describe('InMemoryApprovalStore', () => {
+    let store;
+    beforeEach(() => {
+        store = new memory_1.InMemoryApprovalStore();
+    });
+    // -- save and getById -----------------------------------------------------
+    describe('save and getById', () => {
+        it('returns undefined for a non-existent approval', () => {
+            expect(store.getById('no-such-id')).toBeUndefined();
+        });
+        it('saves and retrieves an approval by ID', () => {
+            const approval = makeApprovalRecord({
+                approval_id: 'apr-001',
+                tool_call_id: 'tc-001',
+                workspace_id: 'ws-001',
+            });
+            store.save('apr-001', approval);
+            expect(store.getById('apr-001')).toEqual(approval);
+        });
+        it('overwrites existing approval with same ID', () => {
+            store.save('apr-001', makeApprovalRecord({ status: 'pending' }));
+            store.save('apr-001', makeApprovalRecord({ status: 'approved' }));
+            expect(store.getById('apr-001')?.status).toBe('approved');
+        });
+    });
+    // -- getByToken via indexToken --------------------------------------------
+    describe('getByToken via indexToken', () => {
+        it('returns undefined for an unindexed token', () => {
+            expect(store.getByToken('token-xyz')).toBeUndefined();
+        });
+        it('retrieves approval by its indexed token', () => {
+            const approval = makeApprovalRecord({ approval_id: 'apr-001', status: 'pending' });
+            store.save('apr-001', approval);
+            store.indexToken('jwt-token-abc', 'apr-001');
+            expect(store.getByToken('jwt-token-abc')).toEqual(approval);
+        });
+        it('returns undefined if token references a deleted/missing approval', () => {
+            store.indexToken('orphan-token', 'missing-id');
+            expect(store.getByToken('orphan-token')).toBeUndefined();
+        });
+        it('supports multiple tokens pointing to different approvals', () => {
+            const apr1 = makeApprovalRecord({ approval_id: 'apr-001' });
+            const apr2 = makeApprovalRecord({ approval_id: 'apr-002' });
+            store.save('apr-001', apr1);
+            store.save('apr-002', apr2);
+            store.indexToken('token-1', 'apr-001');
+            store.indexToken('token-2', 'apr-002');
+            expect(store.getByToken('token-1')).toEqual(apr1);
+            expect(store.getByToken('token-2')).toEqual(apr2);
+        });
+    });
+    // -- getByToolCallId ------------------------------------------------------
+    describe('getByToolCallId', () => {
+        it('returns undefined when no approvals match', () => {
+            store.save('apr-001', makeApprovalRecord({ tool_call_id: 'tc-AAA' }));
+            expect(store.getByToolCallId('tc-ZZZ')).toBeUndefined();
+        });
+        it('searches all approvals and returns the matching one', () => {
+            store.save('apr-001', makeApprovalRecord({ tool_call_id: 'tc-001', status: 'pending' }));
+            store.save('apr-002', makeApprovalRecord({ tool_call_id: 'tc-002', status: 'pending' }));
+            store.save('apr-003', makeApprovalRecord({ tool_call_id: 'tc-003', status: 'approved' }));
+            const result = store.getByToolCallId('tc-002');
+            expect(result).toMatchObject({ tool_call_id: 'tc-002', status: 'pending' });
+        });
+        it('returns the first match when multiple approvals share the same tool_call_id', () => {
+            store.save('apr-001', makeApprovalRecord({ tool_call_id: 'tc-dup', approval_id: 'apr-001' }));
+            store.save('apr-002', makeApprovalRecord({ tool_call_id: 'tc-dup', approval_id: 'apr-002' }));
+            const result = store.getByToolCallId('tc-dup');
+            // Map iteration order is insertion order, so first saved wins
+            expect(result?.approval_id).toBe('apr-001');
+        });
+    });
+    // -- findPending ----------------------------------------------------------
+    describe('findPending', () => {
+        it('returns only pending approvals', () => {
+            store.save('apr-001', makeApprovalRecord({ status: 'pending', workspace_id: 'ws-001' }));
+            store.save('apr-002', makeApprovalRecord({ status: 'approved', workspace_id: 'ws-001' }));
+            store.save('apr-003', makeApprovalRecord({ status: 'pending', workspace_id: 'ws-001' }));
+            store.save('apr-004', makeApprovalRecord({ status: 'denied', workspace_id: 'ws-001' }));
+            const pending = store.findPending();
+            expect(pending).toHaveLength(2);
+            expect(pending.every((a) => a.status === 'pending')).toBe(true);
+        });
+        it('returns empty array when nothing is pending', () => {
+            store.save('apr-001', makeApprovalRecord({ status: 'approved', workspace_id: 'ws-001' }));
+            expect(store.findPending()).toEqual([]);
+        });
+        it('filters by workspace when workspaceId is provided', () => {
+            store.save('apr-001', makeApprovalRecord({ status: 'pending', workspace_id: 'ws-A' }));
+            store.save('apr-002', makeApprovalRecord({ status: 'pending', workspace_id: 'ws-B' }));
+            store.save('apr-003', makeApprovalRecord({ status: 'pending', workspace_id: 'ws-A' }));
+            const wsA = store.findPending('ws-A');
+            expect(wsA).toHaveLength(2);
+            expect(wsA.every((a) => a.workspace_id === 'ws-A')).toBe(true);
+            const wsB = store.findPending('ws-B');
+            expect(wsB).toHaveLength(1);
+            expect(wsB[0].workspace_id).toBe('ws-B');
+        });
+        it('returns empty array when workspace has no pending items', () => {
+            store.save('apr-001', makeApprovalRecord({ status: 'pending', workspace_id: 'ws-A' }));
+            expect(store.findPending('ws-Z')).toEqual([]);
+        });
+        it('returns all pending when workspaceId is undefined', () => {
+            store.save('apr-001', makeApprovalRecord({ status: 'pending', workspace_id: 'ws-A' }));
+            store.save('apr-002', makeApprovalRecord({ status: 'pending', workspace_id: 'ws-B' }));
+            const all = store.findPending(undefined);
+            expect(all).toHaveLength(2);
+        });
+    });
+    // -- clear ----------------------------------------------------------------
+    describe('clear()', () => {
+        it('empties both approvals and token index maps', () => {
+            store.save('apr-001', makeApprovalRecord({ status: 'pending', tool_call_id: 'tc-001' }));
+            store.indexToken('token-abc', 'apr-001');
+            store.clear();
+            expect(store.getById('apr-001')).toBeUndefined();
+            expect(store.getByToken('token-abc')).toBeUndefined();
+            expect(store.findPending()).toEqual([]);
+        });
+        it('allows saving new approvals after clearing', () => {
+            const apr1 = makeApprovalRecord({ approval_id: 'apr-001', status: 'pending' });
+            const apr2 = makeApprovalRecord({ approval_id: 'apr-002', status: 'pending' });
+            store.save('apr-001', apr1);
+            store.clear();
+            store.save('apr-002', apr2);
+            expect(store.getById('apr-001')).toBeUndefined();
+            expect(store.getById('apr-002')).toEqual(apr2);
+        });
+    });
+});
+// ---------------------------------------------------------------------------
+// InMemoryIdempotencyStore
+// ---------------------------------------------------------------------------
+describe('InMemoryIdempotencyStore', () => {
+    let store;
+    let realDateNow;
+    beforeEach(() => {
+        store = new memory_1.InMemoryIdempotencyStore();
+        realDateNow = Date.now;
+    });
+    afterEach(() => {
+        Date.now = realDateNow;
+    });
+    // -- set and get ----------------------------------------------------------
+    describe('set and get', () => {
+        it('returns undefined for a key that was never set', async () => {
+            expect(await store.get('unknown')).toBeUndefined();
+        });
+        it('returns the cached result within TTL', async () => {
+            const result = makeToolResult({ tool_call_id: 'tc-001' });
+            store.set('tc-001', result, 60000);
+            expect(await store.get('tc-001')).toEqual(result);
+        });
+        it('stores different results for different keys', async () => {
+            const resultA = makeToolResult({ tool_call_id: 'tc-A' });
+            const resultB = makeToolResult({ tool_call_id: 'tc-B' });
+            store.set('tc-A', resultA, 60000);
+            store.set('tc-B', resultB, 60000);
+            expect(await store.get('tc-A')).toEqual(resultA);
+            expect(await store.get('tc-B')).toEqual(resultB);
+        });
+        it('overwrites previous value for the same key', async () => {
+            const result1 = makeToolResult({ tool_call_id: 'tc-v1' });
+            const result2 = makeToolResult({ tool_call_id: 'tc-v2' });
+            store.set('tc-001', result1, 60000);
+            store.set('tc-001', result2, 60000);
+            expect(await store.get('tc-001')).toEqual(result2);
+        });
+    });
+    // -- has ------------------------------------------------------------------
+    describe('has()', () => {
+        it('returns true for a cached and non-expired entry', async () => {
+            store.set('tc-001', makeToolResult(), 60000);
+            expect(await store.has('tc-001')).toBe(true);
+        });
+        it('returns false for a key that was never set', async () => {
+            expect(await store.has('missing')).toBe(false);
+        });
+    });
+    // -- expiration via get ---------------------------------------------------
+    describe('expiration', () => {
+        it('get returns undefined for expired entries', async () => {
+            const baseTime = 1000000;
+            Date.now = jest.fn(() => baseTime);
+            store.set('tc-001', makeToolResult(), 5000);
+            // Advance time past expiration
+            Date.now = jest.fn(() => baseTime + 5001);
+            expect(await store.get('tc-001')).toBeUndefined();
+        });
+        it('has returns false for expired entries', async () => {
+            const baseTime = 1000000;
+            Date.now = jest.fn(() => baseTime);
+            store.set('tc-001', makeToolResult(), 5000);
+            // Advance time past expiration
+            Date.now = jest.fn(() => baseTime + 5001);
+            expect(await store.has('tc-001')).toBe(false);
+        });
+        it('entry is accessible just before expiration', async () => {
+            const baseTime = 1000000;
+            Date.now = jest.fn(() => baseTime);
+            const result = makeToolResult();
+            store.set('tc-001', result, 5000);
+            // Time exactly at expiration boundary (expiresAt = baseTime + 5000)
+            Date.now = jest.fn(() => baseTime + 5000);
+            expect(await store.get('tc-001')).toEqual(result);
+        });
+        it('expired entry is deleted from internal storage on access', async () => {
+            const baseTime = 1000000;
+            Date.now = jest.fn(() => baseTime);
+            store.set('tc-001', makeToolResult(), 1000);
+            // Expire
+            Date.now = jest.fn(() => baseTime + 2000);
+            expect(await store.get('tc-001')).toBeUndefined();
+            // Even if we reset time, the entry was deleted
+            Date.now = jest.fn(() => baseTime);
+            expect(await store.get('tc-001')).toBeUndefined();
+        });
+    });
+    // -- clear ----------------------------------------------------------------
+    describe('clear()', () => {
+        it('empties all entries', async () => {
+            store.set('tc-001', makeToolResult({ tool_call_id: 'tc-001' }), 60000);
+            store.set('tc-002', makeToolResult({ tool_call_id: 'tc-002' }), 60000);
+            store.clear();
+            expect(await store.get('tc-001')).toBeUndefined();
+            expect(await store.get('tc-002')).toBeUndefined();
+            expect(await store.has('tc-001')).toBe(false);
+        });
+    });
+    // -- eviction when size > 10000 -------------------------------------------
+    describe('eviction when size > 10000', () => {
+        it('evicts expired entries when map exceeds 10000 entries on set', async () => {
+            const baseTime = 1000000;
+            let currentTime = baseTime;
+            Date.now = jest.fn(() => currentTime);
+            // Fill with 10000 entries that will expire quickly (TTL = 1ms)
+            for (let i = 0; i < 10000; i++) {
+                store.set(`old-${i}`, makeToolResult({ tool_call_id: `old-${i}` }), 1);
+            }
+            // Advance time so all those entries are expired
+            currentTime = baseTime + 100;
+            Date.now = jest.fn(() => currentTime);
+            // Add one more entry to trigger eviction (size > 10000)
+            const triggerResult = makeToolResult({ tool_call_id: 'trigger' });
+            store.set('trigger', triggerResult, 60000);
+            // The new entry should still exist
+            expect(await store.get('trigger')).toEqual(triggerResult);
+            // Old expired entries should have been evicted
+            // (they are not accessible via get because they expired,
+            // but the eviction path also removes them from internal storage)
+            expect(await store.has('old-0')).toBe(false);
+            expect(await store.has('old-9999')).toBe(false);
+        });
+        it('does not evict entries that are still valid', async () => {
+            const baseTime = 1000000;
+            let currentTime = baseTime;
+            Date.now = jest.fn(() => currentTime);
+            // Fill with entries that have a long TTL
+            for (let i = 0; i < 10000; i++) {
+                store.set(`valid-${i}`, makeToolResult({ tool_call_id: `valid-${i}` }), 600000);
+            }
+            // No time advance, entries should still be valid
+            // Trigger set that pushes over 10000
+            const extraResult = makeToolResult({ tool_call_id: 'extra' });
+            store.set('extra', extraResult, 600000);
+            // Valid entries should still be present
+            expect(await store.get('valid-0')).toEqual(makeToolResult({ tool_call_id: 'valid-0' }));
+            expect(await store.get('valid-5000')).toEqual(makeToolResult({ tool_call_id: 'valid-5000' }));
+            expect(await store.get('extra')).toEqual(extraResult);
+        });
+    });
+});
+// ---------------------------------------------------------------------------
+// InMemoryRateLimitStore
+// ---------------------------------------------------------------------------
+describe('InMemoryRateLimitStore', () => {
+    let store;
+    let realDateNow;
+    beforeEach(() => {
+        store = new memory_1.InMemoryRateLimitStore();
+        realDateNow = Date.now;
+    });
+    afterEach(() => {
+        Date.now = realDateNow;
+    });
+    // -- hit records and returns correct counts -------------------------------
+    describe('hit()', () => {
+        it('records a hit and returns correct counts', () => {
+            const result = store.hit('actor:agent-001', 60000, 10);
+            expect(result.current).toBe(1);
+            expect(result.limit).toBe(10);
+            expect(result.allowed).toBe(true);
+            expect(result.resetAt).toBeGreaterThan(Date.now() - 1);
+        });
+        it('accumulates hits for the same key', () => {
+            store.hit('actor:agent-001', 60000, 10);
+            store.hit('actor:agent-001', 60000, 10);
+            const result = store.hit('actor:agent-001', 60000, 10);
+            expect(result.current).toBe(3);
+            expect(result.allowed).toBe(true);
+        });
+        it('tracks different keys independently', () => {
+            store.hit('actor:A', 60000, 10);
+            store.hit('actor:A', 60000, 10);
+            store.hit('actor:B', 60000, 10);
+            const resultA = store.hit('actor:A', 60000, 10);
+            const resultB = store.hit('actor:B', 60000, 10);
+            expect(resultA.current).toBe(3);
+            expect(resultB.current).toBe(2);
+        });
+        it('returns resetAt based on the first timestamp in the window', () => {
+            const baseTime = 1000000;
+            Date.now = jest.fn(() => baseTime);
+            const result = store.hit('key', 60000, 10);
+            expect(result.resetAt).toBe(baseTime + 60000);
+        });
+    });
+    // -- prunes expired timestamps --------------------------------------------
+    describe('prunes expired timestamps', () => {
+        it('removes timestamps outside the sliding window', () => {
+            const baseTime = 1000000;
+            const windowMs = 10000;
+            // Record hits at baseTime
+            Date.now = jest.fn(() => baseTime);
+            store.hit('key', windowMs, 100);
+            store.hit('key', windowMs, 100);
+            store.hit('key', windowMs, 100);
+            // Advance time past the window
+            Date.now = jest.fn(() => baseTime + windowMs + 1);
+            const result = store.hit('key', windowMs, 100);
+            // Old hits should be pruned, only the new one remains
+            expect(result.current).toBe(1);
+        });
+        it('keeps hits within the window and prunes old ones', () => {
+            const baseTime = 1000000;
+            const windowMs = 10000;
+            // Record hits at baseTime
+            Date.now = jest.fn(() => baseTime);
+            store.hit('key', windowMs, 100);
+            store.hit('key', windowMs, 100);
+            // Record a hit at baseTime + 5000 (still in window)
+            Date.now = jest.fn(() => baseTime + 5000);
+            store.hit('key', windowMs, 100);
+            // Advance to baseTime + 11000 (first two hits expire, third survives)
+            Date.now = jest.fn(() => baseTime + 11000);
+            const result = store.hit('key', windowMs, 100);
+            // Two old hits pruned, one surviving + one new = 2
+            expect(result.current).toBe(2);
+        });
+    });
+    // -- allowed is false when over limit -------------------------------------
+    describe('rate limiting enforcement', () => {
+        it('allowed is false when hits exceed maxRequests', () => {
+            const maxRequests = 3;
+            store.hit('key', 60000, maxRequests);
+            store.hit('key', 60000, maxRequests);
+            store.hit('key', 60000, maxRequests);
+            // Fourth hit exceeds the limit
+            const result = store.hit('key', 60000, maxRequests);
+            expect(result.current).toBe(4);
+            expect(result.allowed).toBe(false);
+        });
+        it('allowed is true when exactly at maxRequests', () => {
+            const maxRequests = 3;
+            store.hit('key', 60000, maxRequests);
+            store.hit('key', 60000, maxRequests);
+            const result = store.hit('key', 60000, maxRequests);
+            expect(result.current).toBe(3);
+            expect(result.allowed).toBe(true);
+        });
+        it('becomes allowed again after window expires', () => {
+            const baseTime = 1000000;
+            const windowMs = 5000;
+            const maxRequests = 2;
+            Date.now = jest.fn(() => baseTime);
+            store.hit('key', windowMs, maxRequests);
+            store.hit('key', windowMs, maxRequests);
+            // At limit
+            let result = store.hit('key', windowMs, maxRequests);
+            expect(result.allowed).toBe(false);
+            // Advance past the window
+            Date.now = jest.fn(() => baseTime + windowMs + 1);
+            result = store.hit('key', windowMs, maxRequests);
+            expect(result.current).toBe(1);
+            expect(result.allowed).toBe(true);
+        });
+    });
+    // -- reset ----------------------------------------------------------------
+    describe('reset()', () => {
+        it('clears all rate limit data', () => {
+            store.hit('actor:A', 60000, 10);
+            store.hit('actor:B', 60000, 10);
+            store.reset();
+            // After reset, a hit should start fresh at count 1
+            const result = store.hit('actor:A', 60000, 10);
+            expect(result.current).toBe(1);
+        });
+    });
+});
+//# sourceMappingURL=storage.test.js.map