@jshookmcp/jshook 0.1.9 → 0.2.1

package/dist/tests/server/workflows/WorkflowEngine.test.js

@@ -0,0 +1,156 @@
+import { beforeEach, describe, expect, it, vi } from 'vitest';
+import { createWorkflow, SequenceNodeBuilder, } from '../../../src/server/workflows/WorkflowContract.js';
+const state = vi.hoisted(() => ({
+    randomUUID: vi.fn(() => 'run-123'),
+}));
+vi.mock('node:crypto', () => ({
+    randomUUID: state.randomUUID,
+}));
+function successResponse(payload) {
+    return {
+        content: [{ type: 'text', text: JSON.stringify({ success: true, ...payload }) }],
+    };
+}
+describe('workflows/WorkflowEngine', () => {
+    beforeEach(() => {
+        vi.useRealTimers();
+        vi.resetModules();
+        vi.clearAllMocks();
+    });
+    it('executes a sequence workflow, merges config, and returns step results', async () => {
+        const { executeExtensionWorkflow } = await import('../../../src/server/workflows/WorkflowEngine.js');
+        const ctx = {
+            baseTier: 'workflow',
+            config: { feature: { enabled: true }, nested: { value: 1 } },
+            executeToolWithTracking: vi.fn(async (name, args) => successResponse({ name, args })),
+        };
+        const workflow = createWorkflow('wf-seq', 'Sequence Workflow')
+            .buildGraph((executionContext) => {
+            expect(executionContext.getConfig('feature.enabled', false)).toBe(true);
+            expect(executionContext.getConfig('override.flag', false)).toBe(true);
+            return new SequenceNodeBuilder('root')
+                .tool('step-1', 'page_navigate', (builder) => builder.input({ url: 'https://example.com' }))
+                .tool('step-2', 'page_click');
+        })
+            .build();
+        const result = await executeExtensionWorkflow(ctx, workflow, {
+            config: { override: { flag: true } },
+            nodeInputOverrides: { 'step-2': { selector: '#submit' } },
+        });
+        expect(result.runId).toBe('run-123');
+        expect(result.profile).toBe('workflow');
+        expect(result.workflowId).toBe('wf-seq');
+        expect(result.stepResults).toHaveProperty('step-1');
+        expect(result.stepResults).toHaveProperty('step-2');
+        expect(ctx.executeToolWithTracking).toHaveBeenNthCalledWith(1, 'page_navigate', {
+            url: 'https://example.com',
+        });
+        expect(ctx.executeToolWithTracking).toHaveBeenNthCalledWith(2, 'page_click', {
+            selector: '#submit',
+        });
+    });
+    it('retries failed tool nodes until they succeed', async () => {
+        vi.useFakeTimers();
+        const { executeExtensionWorkflow } = await import('../../../src/server/workflows/WorkflowEngine.js');
+        const executeToolWithTracking = vi
+            .fn()
+            .mockResolvedValueOnce({
+            content: [{ type: 'text', text: JSON.stringify({ success: false, error: 'retry me' }) }],
+        })
+            .mockResolvedValueOnce(successResponse({ ok: true }));
+        const ctx = {
+            baseTier: 'workflow',
+            config: {},
+            executeToolWithTracking,
+        };
+        const workflow = createWorkflow('wf-retry', 'Retry Workflow')
+            .buildGraph(() => new SequenceNodeBuilder('root').tool('retry-step', 'page_click', (builder) => builder.retry({ maxAttempts: 2, backoffMs: 50, multiplier: 1 })))
+            .build();
+        const promise = executeExtensionWorkflow(ctx, workflow);
+        await vi.advanceTimersByTimeAsync(60);
+        const result = await promise;
+        expect(executeToolWithTracking).toHaveBeenCalledTimes(2);
+        expect(result.stepResults['retry-step']).toEqual(successResponse({ ok: true }));
+    });
+    it('captures parallel step failures when failFast is disabled', async () => {
+        const { executeExtensionWorkflow } = await import('../../../src/server/workflows/WorkflowEngine.js');
+        const ctx = {
+            baseTier: 'workflow',
+            config: {},
+            executeToolWithTracking: vi.fn(async (name) => {
+                if (name === 'bad_tool') {
+                    return {
+                        content: [{ type: 'text', text: JSON.stringify({ success: false, error: 'boom' }) }],
+                    };
+                }
+                return successResponse({ ok: true });
+            }),
+        };
+        const workflow = createWorkflow('wf-parallel', 'Parallel Workflow')
+            .buildGraph(() => new SequenceNodeBuilder('root').parallel('parallel', (builder) => {
+            builder.failFast(false);
+            builder.tool('good-step', 'good_tool');
+            builder.tool('bad-step', 'bad_tool');
+        }))
+            .build();
+        const result = await executeExtensionWorkflow(ctx, workflow);
+        const parallelResult = result.stepResults.parallel;
+        expect(parallelResult[0]?.content).toBeDefined();
+        expect(parallelResult[1]).toEqual({ success: false, error: 'boom' });
+    });
+    it('uses predicate functions and built-in predicates for branch routing', async () => {
+        const { executeExtensionWorkflow } = await import('../../../src/server/workflows/WorkflowEngine.js');
+        const ctx = {
+            baseTier: 'workflow',
+            config: {},
+            executeToolWithTracking: vi.fn(async (name) => successResponse({ name })),
+        };
+        const workflow = createWorkflow('wf-branch', 'Branch Workflow')
+            .buildGraph(() => {
+            const root = new SequenceNodeBuilder('root');
+            root.tool('step-1', 'page_navigate');
+            root.branch('branch-fn', 'always_false', (builder) => {
+                builder.predicateFn(() => true);
+                builder.whenTrue(new SequenceNodeBuilder('true-branch').tool('step-2', 'page_click'));
+                builder.whenFalse(new SequenceNodeBuilder('false-branch').tool('step-3', 'debug_pause'));
+            });
+            root.branch('branch-built-in', 'always_false', (builder) => {
+                builder.whenTrue(new SequenceNodeBuilder('unused').tool('step-4', 'page_type'));
+                builder.whenFalse(new SequenceNodeBuilder('used').tool('step-5', 'debug_pause'));
+            });
+            return root;
+        })
+            .build();
+        const result = await executeExtensionWorkflow(ctx, workflow);
+        expect(result.stepResults).toHaveProperty('step-2');
+        expect(result.stepResults).toHaveProperty('step-5');
+        expect(result.stepResults).not.toHaveProperty('step-3');
+    });
+    it('calls onError when the workflow exceeds its timeout', async () => {
+        vi.useFakeTimers();
+        try {
+            const { executeExtensionWorkflow } = await import('../../../src/server/workflows/WorkflowEngine.js');
+            const onError = vi.fn();
+            const ctx = {
+                baseTier: 'workflow',
+                config: {},
+                executeToolWithTracking: vi.fn(() => new Promise(() => undefined)),
+            };
+            const workflow = createWorkflow('wf-timeout', 'Timeout Workflow')
+                .timeoutMs(25)
+                .buildGraph(() => new SequenceNodeBuilder('root').tool('slow-step', 'slow_tool'))
+                .onError(onError)
+                .build();
+            const promise = executeExtensionWorkflow(ctx, workflow);
+            const caught = promise.catch((e) => e);
+            await vi.advanceTimersByTimeAsync(30);
+            const err = await caught;
+            expect(err).toBeInstanceOf(Error);
+            expect(err.message).toBe('Workflow "wf-timeout" timed out after 25ms');
+            expect(onError).toHaveBeenCalledWith(expect.objectContaining({ workflowRunId: 'run-123' }), expect.objectContaining({ message: 'Workflow "wf-timeout" timed out after 25ms' }));
+        }
+        finally {
+            vi.useRealTimers();
+        }
+    });
+});

package/dist/tests/utils/ArtifactRetention.additional.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/tests/utils/ArtifactRetention.additional.test.js

@@ -0,0 +1,198 @@
+import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest';
+import { mkdtemp, mkdir, rm, writeFile } from 'node:fs/promises';
+import { tmpdir } from 'node:os';
+import { join } from 'node:path';
+vi.mock('@utils/artifacts', () => ({
+    getArtifactsRoot: () => '/mocked/artifacts',
+    getArtifactDir: (category) => `/mocked/artifacts/${category}`,
+}));
+vi.mock('@utils/outputPaths', () => ({
+    getProjectRoot: () => '/mocked/project',
+    resolveOutputDirectory: (_dir, fallback) => `/mocked/${fallback}`,
+}));
+import { cleanupArtifacts, getArtifactRetentionConfig, startArtifactRetentionScheduler, } from '../../src/utils/artifactRetention.js';
+describe('ArtifactRetention – additional coverage', () => {
+    let root;
+    beforeEach(async () => {
+        root = await mkdtemp(join(tmpdir(), 'jshook-ret-'));
+        vi.restoreAllMocks();
+    });
+    afterEach(async () => {
+        await rm(root, { recursive: true, force: true });
+    });
+    describe('startArtifactRetentionScheduler (lines 135-155)', () => {
+        it('returns null when retention is not enabled', () => {
+            const originalRetention = process.env.MCP_ARTIFACT_RETENTION_DAYS;
+            const originalMax = process.env.MCP_ARTIFACT_MAX_TOTAL_MB;
+            const originalInterval = process.env.MCP_ARTIFACT_CLEANUP_INTERVAL_MINUTES;
+            process.env.MCP_ARTIFACT_RETENTION_DAYS = '0';
+            process.env.MCP_ARTIFACT_MAX_TOTAL_MB = '0';
+            process.env.MCP_ARTIFACT_CLEANUP_INTERVAL_MINUTES = '0';
+            const result = startArtifactRetentionScheduler();
+            expect(result).toBeNull();
+            process.env.MCP_ARTIFACT_RETENTION_DAYS = originalRetention;
+            process.env.MCP_ARTIFACT_MAX_TOTAL_MB = originalMax;
+            process.env.MCP_ARTIFACT_CLEANUP_INTERVAL_MINUTES = originalInterval;
+        });
+        it('returns null when enabled but interval is 0', () => {
+            const originalRetention = process.env.MCP_ARTIFACT_RETENTION_DAYS;
+            const originalInterval = process.env.MCP_ARTIFACT_CLEANUP_INTERVAL_MINUTES;
+            process.env.MCP_ARTIFACT_RETENTION_DAYS = '7';
+            process.env.MCP_ARTIFACT_CLEANUP_INTERVAL_MINUTES = '0';
+            const result = startArtifactRetentionScheduler();
+            expect(result).toBeNull();
+            process.env.MCP_ARTIFACT_RETENTION_DAYS = originalRetention;
+            process.env.MCP_ARTIFACT_CLEANUP_INTERVAL_MINUTES = originalInterval;
+        });
+        it('returns a cancel function when properly configured', () => {
+            const originalRetention = process.env.MCP_ARTIFACT_RETENTION_DAYS;
+            const originalInterval = process.env.MCP_ARTIFACT_CLEANUP_INTERVAL_MINUTES;
+            process.env.MCP_ARTIFACT_RETENTION_DAYS = '7';
+            process.env.MCP_ARTIFACT_CLEANUP_INTERVAL_MINUTES = '60';
+            const cancel = startArtifactRetentionScheduler();
+            expect(typeof cancel).toBe('function');
+            if (cancel)
+                cancel();
+            process.env.MCP_ARTIFACT_RETENTION_DAYS = originalRetention;
+            process.env.MCP_ARTIFACT_CLEANUP_INTERVAL_MINUTES = originalInterval;
+        });
+    });
+    describe('getArtifactRetentionConfig', () => {
+        it('parses environment variables correctly', () => {
+            const config = getArtifactRetentionConfig({
+                MCP_ARTIFACT_RETENTION_DAYS: '14',
+                MCP_ARTIFACT_MAX_TOTAL_MB: '512',
+                MCP_ARTIFACT_CLEANUP_INTERVAL_MINUTES: '30',
+                MCP_ARTIFACT_CLEANUP_ON_START: 'true',
+            });
+            expect(config.enabled).toBe(true);
+            expect(config.retentionDays).toBe(14);
+            expect(config.maxTotalBytes).toBe(512 * 1024 * 1024);
+            expect(config.cleanupIntervalMinutes).toBe(30);
+            expect(config.cleanupOnStart).toBe(true);
+        });
+        it('returns disabled config for empty/zero values', () => {
+            const config = getArtifactRetentionConfig({});
+            expect(config.enabled).toBe(false);
+            expect(config.retentionDays).toBe(0);
+            expect(config.maxTotalBytes).toBe(0);
+        });
+        it('handles cleanupOnStart with value "1"', () => {
+            const config = getArtifactRetentionConfig({
+                MCP_ARTIFACT_CLEANUP_ON_START: '1',
+            });
+            expect(config.cleanupOnStart).toBe(true);
+        });
+    });
+    describe('cleanupArtifacts – empty directories (lines 174-192)', () => {
+        it('handles empty directories without errors', async () => {
+            const emptyDir = join(root, 'empty');
+            await mkdir(emptyDir, { recursive: true });
+            const result = await cleanupArtifacts({
+                retentionDays: 1,
+                dryRun: false,
+                directories: [emptyDir],
+            });
+            expect(result.success).toBe(true);
+            expect(result.scannedFiles).toBe(0);
+            expect(result.removedFiles).toBe(0);
+        });
+        it('handles non-existent directories without errors', async () => {
+            const result = await cleanupArtifacts({
+                retentionDays: 1,
+                dryRun: false,
+                directories: [join(root, 'does-not-exist')],
+            });
+            expect(result.success).toBe(true);
+            expect(result.scannedFiles).toBe(0);
+        });
+    });
+    describe('cleanupArtifacts – dry run (line 199)', () => {
+        it('reports files that would be removed without actually removing them', async () => {
+            const dir = join(root, 'dryrun');
+            await mkdir(dir, { recursive: true });
+            const oldFile = join(dir, 'old.json');
+            await writeFile(oldFile, 'test-data');
+            const oldTime = new Date('2024-01-01T00:00:00.000Z');
+            const { utimes } = await import('node:fs/promises');
+            await utimes(oldFile, oldTime, oldTime);
+            const result = await cleanupArtifacts({
+                retentionDays: 1,
+                dryRun: true,
+                now: new Date('2024-06-01T00:00:00.000Z').getTime(),
+                directories: [dir],
+            });
+            expect(result.removedFiles).toBe(1);
+            expect(result.dryRun).toBe(true);
+            const { stat } = await import('node:fs/promises');
+            await expect(stat(oldFile)).resolves.toBeDefined();
+        });
+    });
+    describe('cleanupArtifacts – pruneEmptyDirectories (lines 212-234)', () => {
+        it('prunes empty subdirectories after removing files', async () => {
+            const subDir = join(root, 'prunetest', 'sub', 'deep');
+            await mkdir(subDir, { recursive: true });
+            const file = join(subDir, 'old.txt');
+            await writeFile(file, 'data');
+            const oldTime = new Date('2024-01-01T00:00:00.000Z');
+            const { utimes } = await import('node:fs/promises');
+            await utimes(file, oldTime, oldTime);
+            await cleanupArtifacts({
+                retentionDays: 1,
+                dryRun: false,
+                now: new Date('2024-06-01T00:00:00.000Z').getTime(),
+                directories: [join(root, 'prunetest')],
+            });
+            const { stat } = await import('node:fs/promises');
+            await expect(stat(subDir)).rejects.toThrow();
+        });
+    });
+    describe('cleanupArtifacts – combined age + size limits', () => {
+        it('applies both retention days and size cap', async () => {
+            const dir = join(root, 'combined');
+            await mkdir(dir, { recursive: true });
+            const oldFile = join(dir, 'old.dat');
+            await writeFile(oldFile, 'old-content');
+            const oldTime = new Date('2024-01-01T00:00:00.000Z');
+            const newFile1 = join(dir, 'new1.dat');
+            const newFile2 = join(dir, 'new2.dat');
+            await writeFile(newFile1, 'A'.repeat(1000));
+            await writeFile(newFile2, 'B'.repeat(1000));
+            const newTime = new Date('2024-06-01T00:00:00.000Z');
+            const { utimes } = await import('node:fs/promises');
+            await utimes(oldFile, oldTime, oldTime);
+            await utimes(newFile1, newTime, newTime);
+            await utimes(newFile2, newTime, newTime);
+            const result = await cleanupArtifacts({
+                retentionDays: 30,
+                maxTotalBytes: 500,
+                dryRun: false,
+                now: new Date('2024-06-15T00:00:00.000Z').getTime(),
+                directories: [dir],
+            });
+            expect(result.removedFiles).toBeGreaterThanOrEqual(1);
+            expect(result.success).toBe(true);
+        });
+    });
+    describe('cleanupArtifacts – removedSample limit', () => {
+        it('caps removedSample at 20 entries', async () => {
+            const dir = join(root, 'many-files');
+            await mkdir(dir, { recursive: true });
+            const oldTime = new Date('2024-01-01T00:00:00.000Z');
+            const { utimes } = await import('node:fs/promises');
+            for (let i = 0; i < 25; i++) {
+                const f = join(dir, `file${i}.tmp`);
+                await writeFile(f, `content-${i}`);
+                await utimes(f, oldTime, oldTime);
+            }
+            const result = await cleanupArtifacts({
+                retentionDays: 1,
+                dryRun: true,
+                now: new Date('2024-06-01T00:00:00.000Z').getTime(),
+                directories: [dir],
+            });
+            expect(result.removedSample.length).toBeLessThanOrEqual(20);
+            expect(result.removedFiles).toBe(25);
+        });
+    });
+});

package/dist/tests/utils/TokenBudgetManager.additional.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/tests/utils/TokenBudgetManager.additional.test.js

@@ -0,0 +1,274 @@
+import { beforeEach, describe, expect, it, vi } from 'vitest';
+import { TokenBudgetManager } from '../../src/utils/TokenBudgetManager.js';
+describe('TokenBudgetManager – additional coverage', () => {
+    let manager;
+    beforeEach(() => {
+        manager = new TokenBudgetManager();
+        manager.setTrackingEnabled(true);
+        vi.restoreAllMocks();
+    });
+    describe('generateSuggestions – tool-specific suggestions (lines 387-405)', () => {
+        it('suggests smartMode for collect_code when it uses >30% tokens', () => {
+            const now = Date.now();
+            manager.toolCallHistory = [
+                {
+                    toolName: 'collect_code_scripts',
+                    timestamp: now,
+                    requestSize: 1000,
+                    responseSize: 1000,
+                    estimatedTokens: 80000,
+                    cumulativeTokens: 80000,
+                },
+                {
+                    toolName: 'other_tool',
+                    timestamp: now,
+                    requestSize: 100,
+                    responseSize: 100,
+                    estimatedTokens: 10000,
+                    cumulativeTokens: 90000,
+                },
+            ];
+            manager.currentUsage = 90000;
+            const stats = manager.getStats();
+            expect(stats.suggestions.some((s) => s.includes('collect_code') && s.includes('smartMode'))).toBe(true);
+        });
+        it('suggests preview=true for get_script_source when it uses >30% tokens', () => {
+            const now = Date.now();
+            manager.toolCallHistory = [
+                {
+                    toolName: 'get_script_source_viewer',
+                    timestamp: now,
+                    requestSize: 1000,
+                    responseSize: 1000,
+                    estimatedTokens: 70000,
+                    cumulativeTokens: 70000,
+                },
+                {
+                    toolName: 'other',
+                    timestamp: now,
+                    requestSize: 100,
+                    responseSize: 100,
+                    estimatedTokens: 10000,
+                    cumulativeTokens: 80000,
+                },
+            ];
+            manager.currentUsage = 80000;
+            const stats = manager.getStats();
+            expect(stats.suggestions.some((s) => s.includes('get_script_source') && s.includes('preview'))).toBe(true);
+        });
+        it('suggests reducing limit for network_get_requests when >30% tokens', () => {
+            const now = Date.now();
+            manager.toolCallHistory = [
+                {
+                    toolName: 'network_get_requests_tool',
+                    timestamp: now,
+                    requestSize: 1000,
+                    responseSize: 1000,
+                    estimatedTokens: 60000,
+                    cumulativeTokens: 60000,
+                },
+                {
+                    toolName: 'other',
+                    timestamp: now,
+                    requestSize: 100,
+                    responseSize: 100,
+                    estimatedTokens: 10000,
+                    cumulativeTokens: 70000,
+                },
+            ];
+            manager.currentUsage = 70000;
+            const stats = manager.getStats();
+            expect(stats.suggestions.some((s) => s.includes('network_get_requests') && s.includes('limit'))).toBe(true);
+        });
+        it('suggests specific properties for page_evaluate when >30% tokens', () => {
+            const now = Date.now();
+            manager.toolCallHistory = [
+                {
+                    toolName: 'page_evaluate_helper',
+                    timestamp: now,
+                    requestSize: 1000,
+                    responseSize: 1000,
+                    estimatedTokens: 65000,
+                    cumulativeTokens: 65000,
+                },
+                {
+                    toolName: 'other',
+                    timestamp: now,
+                    requestSize: 100,
+                    responseSize: 100,
+                    estimatedTokens: 10000,
+                    cumulativeTokens: 75000,
+                },
+            ];
+            manager.currentUsage = 75000;
+            const stats = manager.getStats();
+            expect(stats.suggestions.some((s) => s.includes('page_evaluate') && s.includes('properties'))).toBe(true);
+        });
+    });
+    describe('generateSuggestions – ratio-based suggestions (lines 382-388)', () => {
+        it('shows MODERATE suggestion at 80-89% usage', () => {
+            manager.currentUsage = 165000;
+            manager.toolCallHistory = [
+                {
+                    toolName: 'tool1',
+                    timestamp: Date.now(),
+                    requestSize: 100,
+                    responseSize: 100,
+                    estimatedTokens: 165000,
+                    cumulativeTokens: 165000,
+                },
+            ];
+            const stats = manager.getStats();
+            expect(stats.suggestions.some((s) => s.includes('MODERATE'))).toBe(true);
+        });
+        it('shows HIGH suggestion at 90-94% usage', () => {
+            manager.currentUsage = 185000;
+            manager.toolCallHistory = [
+                {
+                    toolName: 'tool1',
+                    timestamp: Date.now(),
+                    requestSize: 100,
+                    responseSize: 100,
+                    estimatedTokens: 185000,
+                    cumulativeTokens: 185000,
+                },
+            ];
+            const stats = manager.getStats();
+            expect(stats.suggestions.some((s) => s.includes('HIGH'))).toBe(true);
+        });
+        it('shows CRITICAL suggestion at >=95% usage', () => {
+            manager.currentUsage = 195000;
+            manager.toolCallHistory = [
+                {
+                    toolName: 'tool1',
+                    timestamp: Date.now(),
+                    requestSize: 100,
+                    responseSize: 100,
+                    estimatedTokens: 195000,
+                    cumulativeTokens: 195000,
+                },
+            ];
+            const stats = manager.getStats();
+            expect(stats.suggestions.some((s) => s.includes('CRITICAL'))).toBe(true);
+        });
+    });
+    describe('isTrackingEnabled (line 430)', () => {
+        it('returns true when tracking is enabled', () => {
+            manager.setTrackingEnabled(true);
+            expect(manager.isTrackingEnabled()).toBe(true);
+        });
+        it('returns false when tracking is disabled', () => {
+            manager.setTrackingEnabled(false);
+            expect(manager.isTrackingEnabled()).toBe(false);
+        });
+    });
+    describe('setTrackingEnabled – no-op on same value', () => {
+        it('does not log when setting the same value', () => {
+            manager.setTrackingEnabled(true);
+            manager.setTrackingEnabled(true);
+            expect(manager.isTrackingEnabled()).toBe(true);
+        });
+    });
+    describe('auto-cleanup – external cleanup failure', () => {
+        it('continues cleanup even when external cleanup throws', () => {
+            const failingCleanup = vi.fn(() => {
+                throw new Error('external cleanup crash');
+            });
+            manager.setExternalCleanup(failingCleanup);
+            const now = Date.now();
+            manager.toolCallHistory = [
+                {
+                    toolName: 'old_call',
+                    timestamp: now - 10 * 60 * 1000,
+                    requestSize: 100,
+                    responseSize: 100,
+                    estimatedTokens: 50,
+                    cumulativeTokens: 50,
+                },
+            ];
+            manager.currentUsage = 50;
+            expect(() => manager.manualCleanup()).not.toThrow();
+            expect(failingCleanup).toHaveBeenCalled();
+            expect(manager.getStats().toolCallCount).toBe(0);
+        });
+    });
+    describe('warning thresholds', () => {
+        it('emits warnings at 80%, 90%, and 95% thresholds', () => {
+            const largeRef = { detailId: 'x', summary: { size: 200_000 } };
+            manager.recordToolCall('big_tool', largeRef, largeRef);
+            let stats = manager.getStats();
+            if (stats.usagePercentage >= 80) {
+                expect(stats.warnings).toContain(80);
+            }
+            manager.recordToolCall('big_tool', largeRef, largeRef);
+            stats = manager.getStats();
+            if (stats.usagePercentage >= 90) {
+                expect(stats.warnings).toContain(90);
+            }
+        });
+    });
+    describe('normalizeForSizeEstimate edge cases', () => {
+        it('handles bigint values', () => {
+            expect(() => manager.recordToolCall('test', { big: BigInt(123) }, { ok: true })).not.toThrow();
+        });
+        it('handles symbol values', () => {
+            expect(() => manager.recordToolCall('test', { sym: Symbol('test') }, { ok: true })).not.toThrow();
+        });
+        it('handles function values', () => {
+            expect(() => manager.recordToolCall('test', { fn: () => { } }, { ok: true })).not.toThrow();
+        });
+        it('handles Error objects', () => {
+            expect(() => manager.recordToolCall('test', new Error('test error'), { ok: true })).not.toThrow();
+        });
+        it('handles Buffer values', () => {
+            expect(() => manager.recordToolCall('test', Buffer.from('hello'), { ok: true })).not.toThrow();
+        });
+        it('handles deeply nested objects', () => {
+            const deep = {};
+            let current = deep;
+            for (let i = 0; i < 10; i++) {
+                current.child = {};
+                current = current.child;
+            }
+            expect(() => manager.recordToolCall('test', deep, { ok: true })).not.toThrow();
+        });
+        it('handles large arrays with truncation', () => {
+            const bigArray = Array.from({ length: 100 }, (_, i) => ({ index: i }));
+            expect(() => manager.recordToolCall('test', bigArray, { ok: true })).not.toThrow();
+        });
+        it('handles objects with many keys', () => {
+            const manyKeys = {};
+            for (let i = 0; i < 100; i++) {
+                manyKeys[`key_${i}`] = i;
+            }
+            expect(() => manager.recordToolCall('test', manyKeys, { ok: true })).not.toThrow();
+        });
+    });
+    describe('reset', () => {
+        it('clears all usage data', () => {
+            manager.recordToolCall('tool1', { x: 1 }, { ok: true });
+            expect(manager.getStats().currentUsage).toBeGreaterThan(0);
+            manager.reset();
+            const stats = manager.getStats();
+            expect(stats.currentUsage).toBe(0);
+            expect(stats.toolCallCount).toBe(0);
+            expect(stats.warnings).toHaveLength(0);
+        });
+    });
+    describe('MCP envelope fast path', () => {
+        it('estimates size for standard MCP response envelope', () => {
+            const mcpResponse = {
+                content: [{ type: 'text', text: 'Hello, world!' }],
+            };
+            expect(() => manager.recordToolCall('test', {}, mcpResponse)).not.toThrow();
+            expect(manager.getStats().currentUsage).toBeGreaterThan(0);
+        });
+        it('estimates size for MCP error envelope', () => {
+            const mcpError = {
+                content: [{ type: 'text', text: 'Something failed' }],
+                isError: true,
+            };
+            expect(() => manager.recordToolCall('test', {}, mcpError)).not.toThrow();
+        });
+    });
+});

package/dist/tests/utils/UnifiedCacheManager.additional.test.d.ts

@@ -0,0 +1 @@
+export {};