@od-oneapp/config 2026.2.2001-canary.1

package/typescript/dist/__tests__/server/structured-clone-tool.test.js

@@ -0,0 +1,751 @@
+import { describe, it, expect, beforeEach, afterEach, vi } from 'vitest';
+import { structuredCloneTool, } from '../../src/server/structured-clone-tool';
+describe('server/structured-clone-tool', () => {
+    describe('tool metadata', () => {
+        it('should have correct tool name', () => {
+            expect(structuredCloneTool.name).toBe('structured_clone');
+        });
+        it('should have a description', () => {
+            expect(structuredCloneTool.description).toBeDefined();
+            expect(typeof structuredCloneTool.description).toBe('string');
+            expect(structuredCloneTool.description.length).toBeGreaterThan(0);
+        });
+        it('should have inputSchema defined', () => {
+            expect(structuredCloneTool.inputSchema).toBeDefined();
+            expect(structuredCloneTool.inputSchema.type).toBe('object');
+            expect(structuredCloneTool.inputSchema.properties).toBeDefined();
+        });
+        it('should have properties in inputSchema', () => {
+            const { properties } = structuredCloneTool.inputSchema;
+            expect(properties).toHaveProperty('action');
+            expect(properties).toHaveProperty('data');
+            expect(properties).toHaveProperty('fallbackToJson');
+            expect(properties).toHaveProperty('validateClone');
+            expect(properties).toHaveProperty('trackPerformance');
+        });
+        it('should require action property', () => {
+            expect(structuredCloneTool.inputSchema.required).toContain('action');
+        });
+        it('should have action enum with all expected actions', () => {
+            const actions = structuredCloneTool.inputSchema.properties.action.enum;
+            expect(actions).toContain('clone');
+            expect(actions).toContain('isAvailable');
+            expect(actions).toContain('benchmark');
+            expect(actions).toContain('cloneArray');
+            expect(actions).toContain('cacheDemo');
+            expect(actions).toContain('configClone');
+            expect(actions).toContain('safeClone');
+            expect(actions).toContain('optimizedClone');
+            expect(actions).toContain('validateClone');
+            expect(actions).toContain('performanceClone');
+        });
+    });
+    describe('execute method', () => {
+        it('should be a function', () => {
+            expect(typeof structuredCloneTool.execute).toBe('function');
+        });
+        it('should return a Promise', () => {
+            const result = structuredCloneTool.execute({
+                action: 'clone',
+                data: { test: 'value' },
+            });
+            expect(result).toBeInstanceOf(Promise);
+        });
+    });
+    describe('isAvailable action', () => {
+        it('should return availability status', async () => {
+            const response = await structuredCloneTool.execute({
+                action: 'isAvailable',
+            });
+            expect(response.content[0]?.type).toBe('text');
+            const content = response.content[0]?.text;
+            expect(content).toContain('structuredCloneAvailable');
+        });
+        it('should include node version in response', async () => {
+            const response = await structuredCloneTool.execute({
+                action: 'isAvailable',
+            });
+            const content = response.content[0]?.text;
+            expect(content).toContain('nodeVersion');
+        });
+        it('should include recommendation in response', async () => {
+            const response = await structuredCloneTool.execute({
+                action: 'isAvailable',
+            });
+            const content = response.content[0]?.text;
+            expect(content).toContain('recommendation');
+        });
+    });
+    describe('clone action', () => {
+        it('should clone simple objects', async () => {
+            const response = await structuredCloneTool.execute({
+                action: 'clone',
+                data: { a: 1, b: 'test', c: true },
+            });
+            expect(response.content[0]?.type).toBe('text');
+            const content = response.content[0]?.text;
+            expect(content).toContain('success');
+            expect(content).toContain('clonedData');
+        });
+        it('should include clone method in response', async () => {
+            const response = await structuredCloneTool.execute({
+                action: 'clone',
+                data: { test: 'data' },
+            });
+            const content = response.content[0]?.text;
+            expect(content).toContain('cloneMethod');
+        });
+        it('should clone with fallback to JSON when specified', async () => {
+            const response = await structuredCloneTool.execute({
+                action: 'clone',
+                data: { test: 'data' },
+                fallbackToJson: true,
+            });
+            expect(response.content[0]?.type).toBe('text');
+            const content = response.content[0]?.text;
+            expect(content).toContain('success');
+        });
+        it('should clone with validation when requested', async () => {
+            const response = await structuredCloneTool.execute({
+                action: 'clone',
+                data: { a: 1, b: 2 },
+                validateClone: true,
+                expectedType: 'object',
+            });
+            const content = response.content[0]?.text;
+            expect(content).toContain('success');
+        });
+        it('should track performance when requested', async () => {
+            const response = await structuredCloneTool.execute({
+                action: 'clone',
+                data: { test: 'data' },
+                trackPerformance: true,
+                performanceMarker: 'test-clone',
+            });
+            const content = response.content[0]?.text;
+            expect(content).toContain('performance');
+        });
+        it('should clone nested objects', async () => {
+            const response = await structuredCloneTool.execute({
+                action: 'clone',
+                data: {
+                    level1: {
+                        level2: {
+                            level3: { value: 42 },
+                        },
+                    },
+                },
+            });
+            const content = response.content[0]?.text;
+            expect(content).toContain('clonedData');
+            expect(content).toContain('level1');
+        });
+        it('should handle null data', async () => {
+            const response = await structuredCloneTool.execute({
+                action: 'clone',
+                data: null,
+            });
+            expect(response.content[0]?.type).toBe('text');
+            const content = response.content[0]?.text;
+            expect(content).toBeDefined();
+        });
+        it('should handle arrays', async () => {
+            const response = await structuredCloneTool.execute({
+                action: 'clone',
+                data: [1, 2, 3, 'test', { nested: true }],
+            });
+            const content = response.content[0]?.text;
+            expect(content).toContain('success');
+        });
+    });
+    describe('benchmark action', () => {
+        it('should benchmark clone methods', async () => {
+            const response = await structuredCloneTool.execute({
+                action: 'benchmark',
+                data: { a: 1, b: 2, c: 3 },
+                iterations: 10,
+            });
+            expect(response.content[0]?.type).toBe('text');
+            const content = response.content[0]?.text;
+            expect(content).toContain('success');
+            expect(content).toContain('benchmark');
+        });
+        it('should include iterations in response', async () => {
+            const response = await structuredCloneTool.execute({
+                action: 'benchmark',
+                data: { test: 'data' },
+                iterations: 50,
+            });
+            const content = response.content[0]?.text;
+            expect(content).toContain('50');
+        });
+        it('should include recommendation in response', async () => {
+            const response = await structuredCloneTool.execute({
+                action: 'benchmark',
+                data: { test: 'data' },
+                iterations: 5,
+            });
+            const content = response.content[0]?.text;
+            expect(content).toContain('recommended');
+        });
+        it('should include data size in response', async () => {
+            const response = await structuredCloneTool.execute({
+                action: 'benchmark',
+                data: { test: 'data' },
+                iterations: 5,
+            });
+            const content = response.content[0]?.text;
+            expect(content).toContain('dataSize');
+        });
+        it('should throw error when data is missing', async () => {
+            const response = await structuredCloneTool.execute({
+                action: 'benchmark',
+                iterations: 10,
+            });
+            expect(response.content[0]?.type).toBe('text');
+            const content = response.content[0]?.text;
+            expect(content).toBeDefined();
+        });
+        it('should use default iterations if not provided', async () => {
+            const response = await structuredCloneTool.execute({
+                action: 'benchmark',
+                data: { test: 'data' },
+            });
+            expect(response.content[0]?.type).toBe('text');
+            const content = response.content[0]?.text;
+            expect(content).toContain('success');
+        });
+    });
+    describe('cloneArray action', () => {
+        it('should clone array elements in batches', async () => {
+            const response = await structuredCloneTool.execute({
+                action: 'cloneArray',
+                data: [1, 2, 3, 4, 5],
+                batchSize: 2,
+            });
+            expect(response.content[0]?.type).toBe('text');
+            const content = response.content[0]?.text;
+            expect(content).toContain('success');
+            expect(content).toContain('cloneArray');
+        });
+        it('should include original length in response', async () => {
+            const response = await structuredCloneTool.execute({
+                action: 'cloneArray',
+                data: [1, 2, 3],
+                batchSize: 1,
+            });
+            const content = response.content[0]?.text;
+            expect(content).toContain('originalLength');
+        });
+        it('should include processed count in response', async () => {
+            const response = await structuredCloneTool.execute({
+                action: 'cloneArray',
+                data: [1, 2, 3, 4, 5],
+                batchSize: 2,
+            });
+            const content = response.content[0]?.text;
+            expect(content).toContain('processedCount');
+        });
+        it('should include batch size in response', async () => {
+            const response = await structuredCloneTool.execute({
+                action: 'cloneArray',
+                data: [1, 2, 3],
+                batchSize: 5,
+            });
+            const content = response.content[0]?.text;
+            expect(content).toContain('batchSize');
+        });
+        it('should handle empty arrays', async () => {
+            const response = await structuredCloneTool.execute({
+                action: 'cloneArray',
+                data: [],
+                batchSize: 2,
+            });
+            expect(response.content[0]?.type).toBe('text');
+            const content = response.content[0]?.text;
+            expect(content).toBeDefined();
+        });
+        it('should reject non-array data with proper response structure', async () => {
+            try {
+                const response = await structuredCloneTool.execute({
+                    action: 'cloneArray',
+                    data: { not: 'array' },
+                });
+                expect(response).toBeDefined();
+                expect(response.content).toBeDefined();
+                expect(Array.isArray(response.content)).toBe(true);
+            }
+            catch (error) {
+                expect(error).toBeDefined();
+            }
+        });
+        it('should use default batch size if not provided', async () => {
+            const response = await structuredCloneTool.execute({
+                action: 'cloneArray',
+                data: [1, 2, 3, 4, 5],
+            });
+            expect(response.content[0]?.type).toBe('text');
+            const content = response.content[0]?.text;
+            expect(content).toBeDefined();
+        });
+        it('should include summary of clone methods used', async () => {
+            const response = await structuredCloneTool.execute({
+                action: 'cloneArray',
+                data: [1, 2, 3],
+                batchSize: 1,
+            });
+            const content = response.content[0]?.text;
+            expect(content).toContain('summary');
+        });
+    });
+    describe('cacheDemo action', () => {
+        it('should demonstrate cache operations', async () => {
+            const response = await structuredCloneTool.execute({
+                action: 'cacheDemo',
+                cacheSize: 5,
+            });
+            expect(response.content[0]?.type).toBe('text');
+            const content = response.content[0]?.text;
+            expect(content).toContain('success');
+            expect(content).toContain('cacheDemo');
+        });
+        it('should include cache size in response', async () => {
+            const response = await structuredCloneTool.execute({
+                action: 'cacheDemo',
+                cacheSize: 10,
+            });
+            const content = response.content[0]?.text;
+            expect(content).toContain('cacheSize');
+        });
+        it('should include cache keys in response', async () => {
+            const response = await structuredCloneTool.execute({
+                action: 'cacheDemo',
+                cacheSize: 3,
+            });
+            const content = response.content[0]?.text;
+            expect(content).toContain('cacheKeys');
+        });
+        it('should demonstrate isolation between original and retrieved', async () => {
+            const response = await structuredCloneTool.execute({
+                action: 'cacheDemo',
+                cacheSize: 5,
+            });
+            const content = response.content[0]?.text;
+            expect(content).toContain('demonstratesIsolation');
+        });
+        it('should use default cache size if not provided', async () => {
+            const response = await structuredCloneTool.execute({
+                action: 'cacheDemo',
+            });
+            expect(response.content[0]?.type).toBe('text');
+            const content = response.content[0]?.text;
+            expect(content).toContain('success');
+        });
+    });
+    describe('configClone action', () => {
+        it('should clone config objects', async () => {
+            const response = await structuredCloneTool.execute({
+                action: 'configClone',
+                data: { database: 'test', port: 5432 },
+            });
+            expect(response.content[0]?.type).toBe('text');
+            const content = response.content[0]?.text;
+            expect(content).toContain('success');
+            expect(content).toContain('configClone');
+        });
+        it('should include original config in response', async () => {
+            const response = await structuredCloneTool.execute({
+                action: 'configClone',
+                data: { test: 'config' },
+            });
+            const content = response.content[0]?.text;
+            expect(content).toContain('originalConfig');
+        });
+        it('should include cloned config in response', async () => {
+            const response = await structuredCloneTool.execute({
+                action: 'configClone',
+                data: { test: 'config' },
+            });
+            const content = response.content[0]?.text;
+            expect(content).toContain('clonedConfig');
+        });
+        it('should indicate validation status', async () => {
+            const response = await structuredCloneTool.execute({
+                action: 'configClone',
+                data: { test: 'config' },
+            });
+            const content = response.content[0]?.text;
+            expect(content).toContain('validated');
+        });
+    });
+    describe('safeClone action', () => {
+        it('should safely clone with fallback', async () => {
+            const response = await structuredCloneTool.execute({
+                action: 'safeClone',
+                data: { test: 'data' },
+                fallback: { error: 'fallback' },
+            });
+            expect(response.content[0]?.type).toBe('text');
+            const content = response.content[0]?.text;
+            expect(content).toContain('success');
+            expect(content).toContain('safeClone');
+        });
+        it('should include fallback data in response', async () => {
+            const response = await structuredCloneTool.execute({
+                action: 'safeClone',
+                data: { test: 'data' },
+                fallback: { default: true },
+            });
+            const content = response.content[0]?.text;
+            expect(content).toContain('fallbackData');
+        });
+        it('should indicate if fallback was used', async () => {
+            const response = await structuredCloneTool.execute({
+                action: 'safeClone',
+                data: { test: 'data' },
+            });
+            const content = response.content[0]?.text;
+            expect(content).toContain('fallbackUsed');
+        });
+        it('should use default fallback if not provided', async () => {
+            const response = await structuredCloneTool.execute({
+                action: 'safeClone',
+                data: { test: 'data' },
+            });
+            expect(response.content[0]?.type).toBe('text');
+            const content = response.content[0]?.text;
+            expect(content).toContain('success');
+        });
+    });
+    describe('optimizedClone action', () => {
+        it('should perform optimized cloning', async () => {
+            const response = await structuredCloneTool.execute({
+                action: 'optimizedClone',
+                data: { test: 'data' },
+            });
+            expect(response.content[0]?.type).toBe('text');
+            const content = response.content[0]?.text;
+            expect(content).toContain('success');
+            expect(content).toContain('optimizedClone');
+        });
+        it('should include optimized method in response', async () => {
+            const response = await structuredCloneTool.execute({
+                action: 'optimizedClone',
+                data: { test: 'data' },
+            });
+            const content = response.content[0]?.text;
+            expect(content).toContain('optimizedMethod');
+        });
+        it('should indicate automatic optimization', async () => {
+            const response = await structuredCloneTool.execute({
+                action: 'optimizedClone',
+                data: { test: 'data' },
+            });
+            const content = response.content[0]?.text;
+            expect(content).toContain('automaticallyOptimized');
+        });
+    });
+    describe('validateClone action', () => {
+        it('should clone with validation', async () => {
+            const response = await structuredCloneTool.execute({
+                action: 'validateClone',
+                data: { test: 'data' },
+                expectedType: 'object',
+            });
+            expect(response.content[0]?.type).toBe('text');
+            const content = response.content[0]?.text;
+            expect(content).toContain('success');
+            expect(content).toContain('validateClone');
+        });
+        it('should include validation status in response', async () => {
+            const response = await structuredCloneTool.execute({
+                action: 'validateClone',
+                data: { test: 'data' },
+            });
+            const content = response.content[0]?.text;
+            expect(content).toContain('validationPassed');
+        });
+        it('should include warnings in response', async () => {
+            const response = await structuredCloneTool.execute({
+                action: 'validateClone',
+                data: { test: 'data' },
+                expectedType: 'string',
+            });
+            const content = response.content[0]?.text;
+            expect(content).toContain('warnings');
+        });
+        it('should include performance in response', async () => {
+            const response = await structuredCloneTool.execute({
+                action: 'validateClone',
+                data: { test: 'data' },
+            });
+            const content = response.content[0]?.text;
+            expect(content).toContain('performance');
+        });
+    });
+    describe('performanceClone action', () => {
+        it('should clone with performance metrics', async () => {
+            const response = await structuredCloneTool.execute({
+                action: 'performanceClone',
+                data: { test: 'data' },
+            });
+            expect(response.content[0]?.type).toBe('text');
+            const content = response.content[0]?.text;
+            expect(content).toContain('success');
+            expect(content).toContain('performanceClone');
+        });
+        it('should include performance marker in response', async () => {
+            const response = await structuredCloneTool.execute({
+                action: 'performanceClone',
+                data: { test: 'data' },
+                performanceMarker: 'test-perf',
+            });
+            const content = response.content[0]?.text;
+            expect(content).toContain('performanceMarker');
+            expect(content).toContain('test-perf');
+        });
+        it('should generate marker if not provided', async () => {
+            const response = await structuredCloneTool.execute({
+                action: 'performanceClone',
+                data: { test: 'data' },
+            });
+            const content = response.content[0]?.text;
+            expect(content).toContain('performanceMarker');
+        });
+        it('should include performance metrics', async () => {
+            const response = await structuredCloneTool.execute({
+                action: 'performanceClone',
+                data: { test: 'data' },
+            });
+            const content = response.content[0]?.text;
+            expect(content).toContain('performance');
+        });
+        it('should include data size in response', async () => {
+            const response = await structuredCloneTool.execute({
+                action: 'performanceClone',
+                data: { test: 'data' },
+            });
+            const content = response.content[0]?.text;
+            expect(content).toContain('dataSize');
+        });
+        it('should calculate efficiency metric', async () => {
+            const response = await structuredCloneTool.execute({
+                action: 'performanceClone',
+                data: { test: 'data' },
+            });
+            const content = response.content[0]?.text;
+            expect(content).toContain('efficiency');
+        });
+    });
+    describe('demo data generation', () => {
+        it('should generate demo data when generateDemoData is true', async () => {
+            const response = await structuredCloneTool.execute({
+                action: 'clone',
+                generateDemoData: true,
+                demoDataType: 'simple',
+            });
+            expect(response.content[0]?.type).toBe('text');
+            const content = response.content[0]?.text;
+            expect(content).toContain('success');
+        });
+        it('should generate complex demo data', async () => {
+            const response = await structuredCloneTool.execute({
+                action: 'clone',
+                generateDemoData: true,
+                demoDataType: 'complex',
+                demoDataSize: 50,
+            });
+            const content = response.content[0]?.text;
+            expect(content).toContain('success');
+        });
+        it('should generate nested demo data', async () => {
+            const response = await structuredCloneTool.execute({
+                action: 'clone',
+                generateDemoData: true,
+                demoDataType: 'nested',
+                demoDataSize: 10,
+            });
+            const content = response.content[0]?.text;
+            expect(content).toContain('success');
+        });
+        it('should generate large demo data', async () => {
+            const response = await structuredCloneTool.execute({
+                action: 'clone',
+                generateDemoData: true,
+                demoDataType: 'large',
+                demoDataSize: 100,
+            });
+            const content = response.content[0]?.text;
+            expect(content).toContain('success');
+        });
+        it('should handle demo data generation with structured clone', async () => {
+            const response = await structuredCloneTool.execute({
+                action: 'clone',
+                generateDemoData: true,
+                demoDataType: 'simple',
+            });
+            expect(response.content[0]?.type).toBe('text');
+            const content = response.content[0]?.text;
+            expect(content).toContain('success');
+        });
+        it('should use default demo data type if not provided', async () => {
+            const response = await structuredCloneTool.execute({
+                action: 'clone',
+                generateDemoData: true,
+            });
+            expect(response.content[0]?.type).toBe('text');
+            const content = response.content[0]?.text;
+            expect(content).toBeDefined();
+        });
+    });
+    describe('error handling', () => {
+        it('should handle invalid action with error response', async () => {
+            try {
+                const response = await structuredCloneTool.execute({
+                    action: 'invalidAction',
+                });
+                expect(response).toBeDefined();
+                expect(response.content).toBeDefined();
+                expect(response.content[0]?.type).toBe('text');
+            }
+            catch (error) {
+                expect(error).toBeDefined();
+            }
+        });
+        it('should handle abort signal', async () => {
+            const controller = new AbortController();
+            controller.abort();
+            const response = await structuredCloneTool.execute({
+                action: 'clone',
+                data: { test: 'data' },
+                signal: controller.signal,
+            });
+            expect(response.content[0]?.type).toBe('text');
+            const content = response.content[0]?.text;
+            expect(content).toBeDefined();
+        });
+        it('should return error response structure', async () => {
+            const response = await structuredCloneTool.execute({
+                action: 'clone',
+            });
+            expect(response).toHaveProperty('content');
+            expect(Array.isArray(response.content)).toBe(true);
+            expect(response.content[0]).toHaveProperty('type');
+            expect(response.content[0]).toHaveProperty('text');
+        });
+        it('should handle missing required parameters with error response', async () => {
+            try {
+                const response = await structuredCloneTool.execute({});
+                expect(response).toBeDefined();
+                expect(response.content).toBeDefined();
+                expect(response.content[0]?.type).toBe('text');
+            }
+            catch (error) {
+                expect(error).toBeDefined();
+            }
+        });
+    });
+    describe('integration tests', () => {
+        it('should work with multiple actions in sequence', async () => {
+            const availResponse = await structuredCloneTool.execute({
+                action: 'isAvailable',
+            });
+            expect(availResponse.content[0]?.text).toContain('structuredCloneAvailable');
+            const cloneResponse = await structuredCloneTool.execute({
+                action: 'clone',
+                data: { test: 'data' },
+            });
+            expect(cloneResponse.content[0]?.text).toContain('success');
+            const benchResponse = await structuredCloneTool.execute({
+                action: 'benchmark',
+                data: { test: 'data' },
+                iterations: 5,
+            });
+            expect(benchResponse.content[0]?.text).toContain('benchmark');
+        });
+        it('should handle fallback chain correctly', async () => {
+            const response = await structuredCloneTool.execute({
+                action: 'clone',
+                data: { test: 'data' },
+                fallbackToJson: true,
+                validateClone: false,
+            });
+            expect(response.content[0]?.text).toContain('success');
+        });
+        it('should support various data types across actions', async () => {
+            const dataTypes = [
+                { simple: 'string' },
+                [1, 2, 3],
+                null,
+                42,
+                true,
+            ];
+            for (const data of dataTypes) {
+                const response = await structuredCloneTool.execute({
+                    action: 'clone',
+                    data,
+                });
+                expect(response.content[0]?.type).toBe('text');
+            }
+        });
+        it('should handle large datasets', async () => {
+            const largeData = {
+                items: Array.from({ length: 1000 }, (_, i) => ({
+                    id: i,
+                    value: `Item ${i}`,
+                    nested: { timestamp: Date.now() },
+                })),
+            };
+            const response = await structuredCloneTool.execute({
+                action: 'clone',
+                data: largeData,
+                trackPerformance: true,
+            });
+            expect(response.content[0]?.text).toContain('success');
+        });
+    });
+    describe('options validation', () => {
+        it('should accept fallbackToJson option', async () => {
+            const response = await structuredCloneTool.execute({
+                action: 'clone',
+                data: { test: 'data' },
+                fallbackToJson: false,
+            });
+            expect(response.content[0]?.type).toBe('text');
+        });
+        it('should accept validateClone option', async () => {
+            const response = await structuredCloneTool.execute({
+                action: 'clone',
+                data: { test: 'data' },
+                validateClone: true,
+            });
+            expect(response.content[0]?.type).toBe('text');
+        });
+        it('should accept trackPerformance option', async () => {
+            const response = await structuredCloneTool.execute({
+                action: 'clone',
+                data: { test: 'data' },
+                trackPerformance: true,
+            });
+            expect(response.content[0]?.type).toBe('text');
+        });
+        it('should accept expectedType option', async () => {
+            const response = await structuredCloneTool.execute({
+                action: 'clone',
+                data: { test: 'data' },
+                expectedType: 'object',
+            });
+            expect(response.content[0]?.type).toBe('text');
+        });
+        it('should accept performanceMarker option', async () => {
+            const response = await structuredCloneTool.execute({
+                action: 'performanceClone',
+                data: { test: 'data' },
+                performanceMarker: 'custom-marker',
+            });
+            const content = response.content[0]?.text;
+            expect(content).toContain('custom-marker');
+        });
+    });
+});
+//# sourceMappingURL=structured-clone-tool.test.js.map