scorecard-ai-mcp 1.0.0-alpha.4

package/compat.test.js

@@ -0,0 +1,950 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const compat_1 = require("./compat.js");
+describe('truncateToolNames', () => {
+    it('should return original names when maxLength is 0 or negative', () => {
+        const names = ['tool1', 'tool2', 'tool3'];
+        expect((0, compat_1.truncateToolNames)(names, 0)).toEqual(new Map());
+        expect((0, compat_1.truncateToolNames)(names, -1)).toEqual(new Map());
+    });
+    it('should return original names when all names are shorter than maxLength', () => {
+        const names = ['tool1', 'tool2', 'tool3'];
+        expect((0, compat_1.truncateToolNames)(names, 10)).toEqual(new Map());
+    });
+    it('should truncate names longer than maxLength', () => {
+        const names = ['very-long-tool-name', 'another-long-tool-name', 'short'];
+        expect((0, compat_1.truncateToolNames)(names, 10)).toEqual(new Map([
+            ['very-long-tool-name', 'very-long-'],
+            ['another-long-tool-name', 'another-lo'],
+        ]));
+    });
+    it('should handle duplicate truncated names by appending numbers', () => {
+        const names = ['tool-name-a', 'tool-name-b', 'tool-name-c'];
+        expect((0, compat_1.truncateToolNames)(names, 8)).toEqual(new Map([
+            ['tool-name-a', 'tool-na1'],
+            ['tool-name-b', 'tool-na2'],
+            ['tool-name-c', 'tool-na3'],
+        ]));
+    });
+});
+describe('removeTopLevelUnions', () => {
+    const createTestTool = (overrides = {}) => ({
+        name: 'test-tool',
+        description: 'Test tool',
+        inputSchema: {
+            type: 'object',
+            properties: {},
+        },
+        ...overrides,
+    });
+    it('should return the original tool if it has no anyOf at the top level', () => {
+        const tool = createTestTool({
+            inputSchema: {
+                type: 'object',
+                properties: {
+                    foo: { type: 'string' },
+                },
+            },
+        });
+        expect((0, compat_1.removeTopLevelUnions)(tool)).toEqual([tool]);
+    });
+    it('should split a tool with top-level anyOf into multiple tools', () => {
+        const tool = createTestTool({
+            name: 'union-tool',
+            description: 'A tool with unions',
+            inputSchema: {
+                type: 'object',
+                properties: {
+                    common: { type: 'string' },
+                },
+                anyOf: [
+                    {
+                        title: 'first variant',
+                        description: 'Its the first variant',
+                        properties: {
+                            variant1: { type: 'string' },
+                        },
+                        required: ['variant1'],
+                    },
+                    {
+                        title: 'second variant',
+                        properties: {
+                            variant2: { type: 'number' },
+                        },
+                        required: ['variant2'],
+                    },
+                ],
+            },
+        });
+        const result = (0, compat_1.removeTopLevelUnions)(tool);
+        expect(result).toEqual([
+            {
+                name: 'union-tool_first_variant',
+                description: 'Its the first variant',
+                inputSchema: {
+                    type: 'object',
+                    title: 'first variant',
+                    description: 'Its the first variant',
+                    properties: {
+                        common: { type: 'string' },
+                        variant1: { type: 'string' },
+                    },
+                    required: ['variant1'],
+                },
+            },
+            {
+                name: 'union-tool_second_variant',
+                description: 'A tool with unions',
+                inputSchema: {
+                    type: 'object',
+                    title: 'second variant',
+                    description: 'A tool with unions',
+                    properties: {
+                        common: { type: 'string' },
+                        variant2: { type: 'number' },
+                    },
+                    required: ['variant2'],
+                },
+            },
+        ]);
+    });
+    it('should handle $defs and only include those used by the variant', () => {
+        const tool = createTestTool({
+            name: 'defs-tool',
+            description: 'A tool with $defs',
+            inputSchema: {
+                type: 'object',
+                properties: {
+                    common: { type: 'string' },
+                },
+                $defs: {
+                    def1: { type: 'string', format: 'email' },
+                    def2: { type: 'number', minimum: 0 },
+                    unused: { type: 'boolean' },
+                },
+                anyOf: [
+                    {
+                        properties: {
+                            email: { $ref: '#/$defs/def1' },
+                        },
+                    },
+                    {
+                        properties: {
+                            count: { $ref: '#/$defs/def2' },
+                        },
+                    },
+                ],
+            },
+        });
+        const result = (0, compat_1.removeTopLevelUnions)(tool);
+        expect(result).toEqual([
+            {
+                name: 'defs-tool_variant1',
+                description: 'A tool with $defs',
+                inputSchema: {
+                    type: 'object',
+                    description: 'A tool with $defs',
+                    properties: {
+                        common: { type: 'string' },
+                        email: { $ref: '#/$defs/def1' },
+                    },
+                    $defs: {
+                        def1: { type: 'string', format: 'email' },
+                    },
+                },
+            },
+            {
+                name: 'defs-tool_variant2',
+                description: 'A tool with $defs',
+                inputSchema: {
+                    type: 'object',
+                    description: 'A tool with $defs',
+                    properties: {
+                        common: { type: 'string' },
+                        count: { $ref: '#/$defs/def2' },
+                    },
+                    $defs: {
+                        def2: { type: 'number', minimum: 0 },
+                    },
+                },
+            },
+        ]);
+    });
+});
+describe('removeAnyOf', () => {
+    it('should return original schema if it has no anyOf', () => {
+        const schema = {
+            type: 'object',
+            properties: {
+                foo: { type: 'string' },
+                bar: { type: 'number' },
+            },
+        };
+        expect((0, compat_1.removeAnyOf)(schema)).toEqual(schema);
+    });
+    it('should remove anyOf field and use the first variant', () => {
+        const schema = {
+            type: 'object',
+            properties: {
+                common: { type: 'string' },
+            },
+            anyOf: [
+                {
+                    properties: {
+                        variant1: { type: 'string' },
+                    },
+                    required: ['variant1'],
+                },
+                {
+                    properties: {
+                        variant2: { type: 'number' },
+                    },
+                    required: ['variant2'],
+                },
+            ],
+        };
+        const expected = {
+            type: 'object',
+            properties: {
+                common: { type: 'string' },
+                variant1: { type: 'string' },
+            },
+            required: ['variant1'],
+        };
+        expect((0, compat_1.removeAnyOf)(schema)).toEqual(expected);
+    });
+    it('should recursively remove anyOf fields from nested properties', () => {
+        const schema = {
+            type: 'object',
+            properties: {
+                foo: { type: 'string' },
+                nested: {
+                    type: 'object',
+                    properties: {
+                        bar: { type: 'number' },
+                    },
+                    anyOf: [
+                        {
+                            properties: {
+                                option1: { type: 'boolean' },
+                            },
+                        },
+                        {
+                            properties: {
+                                option2: { type: 'array' },
+                            },
+                        },
+                    ],
+                },
+            },
+        };
+        const expected = {
+            type: 'object',
+            properties: {
+                foo: { type: 'string' },
+                nested: {
+                    type: 'object',
+                    properties: {
+                        bar: { type: 'number' },
+                        option1: { type: 'boolean' },
+                    },
+                },
+            },
+        };
+        expect((0, compat_1.removeAnyOf)(schema)).toEqual(expected);
+    });
+    it('should handle arrays', () => {
+        const schema = {
+            type: 'object',
+            properties: {
+                items: {
+                    type: 'array',
+                    items: {
+                        anyOf: [{ type: 'string' }, { type: 'number' }],
+                    },
+                },
+            },
+        };
+        const expected = {
+            type: 'object',
+            properties: {
+                items: {
+                    type: 'array',
+                    items: {
+                        type: 'string',
+                    },
+                },
+            },
+        };
+        expect((0, compat_1.removeAnyOf)(schema)).toEqual(expected);
+    });
+});
+describe('inlineRefs', () => {
+    it('should return the original schema if it does not contain $refs', () => {
+        const schema = {
+            type: 'object',
+            properties: {
+                name: { type: 'string' },
+                age: { type: 'number' },
+            },
+        };
+        expect((0, compat_1.inlineRefs)(schema)).toEqual(schema);
+    });
+    it('should inline simple $refs', () => {
+        const schema = {
+            type: 'object',
+            properties: {
+                user: { $ref: '#/$defs/user' },
+            },
+            $defs: {
+                user: {
+                    type: 'object',
+                    properties: {
+                        name: { type: 'string' },
+                        email: { type: 'string' },
+                    },
+                },
+            },
+        };
+        const expected = {
+            type: 'object',
+            properties: {
+                user: {
+                    type: 'object',
+                    properties: {
+                        name: { type: 'string' },
+                        email: { type: 'string' },
+                    },
+                },
+            },
+        };
+        expect((0, compat_1.inlineRefs)(schema)).toEqual(expected);
+    });
+    it('should inline nested $refs', () => {
+        const schema = {
+            type: 'object',
+            properties: {
+                order: { $ref: '#/$defs/order' },
+            },
+            $defs: {
+                order: {
+                    type: 'object',
+                    properties: {
+                        id: { type: 'string' },
+                        items: { type: 'array', items: { $ref: '#/$defs/item' } },
+                    },
+                },
+                item: {
+                    type: 'object',
+                    properties: {
+                        product: { type: 'string' },
+                        quantity: { type: 'integer' },
+                    },
+                },
+            },
+        };
+        const expected = {
+            type: 'object',
+            properties: {
+                order: {
+                    type: 'object',
+                    properties: {
+                        id: { type: 'string' },
+                        items: {
+                            type: 'array',
+                            items: {
+                                type: 'object',
+                                properties: {
+                                    product: { type: 'string' },
+                                    quantity: { type: 'integer' },
+                                },
+                            },
+                        },
+                    },
+                },
+            },
+        };
+        expect((0, compat_1.inlineRefs)(schema)).toEqual(expected);
+    });
+    it('should handle circular references by removing the circular part', () => {
+        const schema = {
+            type: 'object',
+            properties: {
+                person: { $ref: '#/$defs/person' },
+            },
+            $defs: {
+                person: {
+                    type: 'object',
+                    properties: {
+                        name: { type: 'string' },
+                        friend: { $ref: '#/$defs/person' }, // Circular reference
+                    },
+                },
+            },
+        };
+        const expected = {
+            type: 'object',
+            properties: {
+                person: {
+                    type: 'object',
+                    properties: {
+                        name: { type: 'string' },
+                        // friend property is removed to break the circular reference
+                    },
+                },
+            },
+        };
+        expect((0, compat_1.inlineRefs)(schema)).toEqual(expected);
+    });
+    it('should handle indirect circular references', () => {
+        const schema = {
+            type: 'object',
+            properties: {
+                node: { $ref: '#/$defs/node' },
+            },
+            $defs: {
+                node: {
+                    type: 'object',
+                    properties: {
+                        value: { type: 'string' },
+                        child: { $ref: '#/$defs/childNode' },
+                    },
+                },
+                childNode: {
+                    type: 'object',
+                    properties: {
+                        value: { type: 'string' },
+                        parent: { $ref: '#/$defs/node' }, // Circular reference through childNode
+                    },
+                },
+            },
+        };
+        const expected = {
+            type: 'object',
+            properties: {
+                node: {
+                    type: 'object',
+                    properties: {
+                        value: { type: 'string' },
+                        child: {
+                            type: 'object',
+                            properties: {
+                                value: { type: 'string' },
+                                // parent property is removed to break the circular reference
+                            },
+                        },
+                    },
+                },
+            },
+        };
+        expect((0, compat_1.inlineRefs)(schema)).toEqual(expected);
+    });
+    it('should preserve other properties when inlining references', () => {
+        const schema = {
+            type: 'object',
+            properties: {
+                address: { $ref: '#/$defs/address', description: 'User address' },
+            },
+            $defs: {
+                address: {
+                    type: 'object',
+                    properties: {
+                        street: { type: 'string' },
+                        city: { type: 'string' },
+                    },
+                    required: ['street'],
+                },
+            },
+        };
+        const expected = {
+            type: 'object',
+            properties: {
+                address: {
+                    type: 'object',
+                    description: 'User address',
+                    properties: {
+                        street: { type: 'string' },
+                        city: { type: 'string' },
+                    },
+                    required: ['street'],
+                },
+            },
+        };
+        expect((0, compat_1.inlineRefs)(schema)).toEqual(expected);
+    });
+});
+describe('removeFormats', () => {
+    it('should return original schema if formats capability is true', () => {
+        const schema = {
+            type: 'object',
+            properties: {
+                date: { type: 'string', description: 'A date field', format: 'date' },
+                email: { type: 'string', description: 'An email field', format: 'email' },
+            },
+        };
+        expect((0, compat_1.removeFormats)(schema, true)).toEqual(schema);
+    });
+    it('should move format to description when formats capability is false', () => {
+        const schema = {
+            type: 'object',
+            properties: {
+                date: { type: 'string', description: 'A date field', format: 'date' },
+                email: { type: 'string', description: 'An email field', format: 'email' },
+            },
+        };
+        const expected = {
+            type: 'object',
+            properties: {
+                date: { type: 'string', description: 'A date field (format: "date")' },
+                email: { type: 'string', description: 'An email field (format: "email")' },
+            },
+        };
+        expect((0, compat_1.removeFormats)(schema, false)).toEqual(expected);
+    });
+    it('should handle properties without description', () => {
+        const schema = {
+            type: 'object',
+            properties: {
+                date: { type: 'string', format: 'date' },
+            },
+        };
+        const expected = {
+            type: 'object',
+            properties: {
+                date: { type: 'string', description: '(format: "date")' },
+            },
+        };
+        expect((0, compat_1.removeFormats)(schema, false)).toEqual(expected);
+    });
+    it('should handle nested properties', () => {
+        const schema = {
+            type: 'object',
+            properties: {
+                user: {
+                    type: 'object',
+                    properties: {
+                        created_at: { type: 'string', description: 'Creation date', format: 'date-time' },
+                    },
+                },
+            },
+        };
+        const expected = {
+            type: 'object',
+            properties: {
+                user: {
+                    type: 'object',
+                    properties: {
+                        created_at: { type: 'string', description: 'Creation date (format: "date-time")' },
+                    },
+                },
+            },
+        };
+        expect((0, compat_1.removeFormats)(schema, false)).toEqual(expected);
+    });
+    it('should handle arrays of objects', () => {
+        const schema = {
+            type: 'object',
+            properties: {
+                dates: {
+                    type: 'array',
+                    items: {
+                        type: 'object',
+                        properties: {
+                            start: { type: 'string', description: 'Start date', format: 'date' },
+                            end: { type: 'string', description: 'End date', format: 'date' },
+                        },
+                    },
+                },
+            },
+        };
+        const expected = {
+            type: 'object',
+            properties: {
+                dates: {
+                    type: 'array',
+                    items: {
+                        type: 'object',
+                        properties: {
+                            start: { type: 'string', description: 'Start date (format: "date")' },
+                            end: { type: 'string', description: 'End date (format: "date")' },
+                        },
+                    },
+                },
+            },
+        };
+        expect((0, compat_1.removeFormats)(schema, false)).toEqual(expected);
+    });
+    it('should handle schemas with $defs', () => {
+        const schema = {
+            type: 'object',
+            properties: {
+                date: { type: 'string', description: 'A date field', format: 'date' },
+            },
+            $defs: {
+                timestamp: {
+                    type: 'string',
+                    description: 'A timestamp field',
+                    format: 'date-time',
+                },
+            },
+        };
+        const expected = {
+            type: 'object',
+            properties: {
+                date: { type: 'string', description: 'A date field (format: "date")' },
+            },
+            $defs: {
+                timestamp: {
+                    type: 'string',
+                    description: 'A timestamp field (format: "date-time")',
+                },
+            },
+        };
+        expect((0, compat_1.removeFormats)(schema, false)).toEqual(expected);
+    });
+});
+describe('applyCompatibilityTransformations', () => {
+    const createTestTool = (name, overrides = {}) => ({
+        name,
+        description: 'Test tool',
+        inputSchema: {
+            type: 'object',
+            properties: {},
+        },
+        ...overrides,
+    });
+    const createTestEndpoint = (tool) => ({
+        tool,
+        handler: jest.fn(),
+        metadata: {
+            resource: 'test',
+            operation: 'read',
+            tags: [],
+        },
+    });
+    it('should not modify endpoints when all capabilities are enabled', () => {
+        const tool = createTestTool('test-tool');
+        const endpoints = [createTestEndpoint(tool)];
+        const capabilities = {
+            topLevelUnions: true,
+            validJson: true,
+            refs: true,
+            unions: true,
+            formats: true,
+            toolNameLength: undefined,
+        };
+        const transformed = (0, compat_1.applyCompatibilityTransformations)(endpoints, capabilities);
+        expect(transformed).toEqual(endpoints);
+    });
+    it('should split tools with top-level unions when topLevelUnions is disabled', () => {
+        const tool = createTestTool('union-tool', {
+            inputSchema: {
+                type: 'object',
+                properties: {
+                    common: { type: 'string' },
+                },
+                anyOf: [
+                    {
+                        title: 'first variant',
+                        properties: {
+                            variant1: { type: 'string' },
+                        },
+                    },
+                    {
+                        title: 'second variant',
+                        properties: {
+                            variant2: { type: 'number' },
+                        },
+                    },
+                ],
+            },
+        });
+        const endpoints = [createTestEndpoint(tool)];
+        const capabilities = {
+            topLevelUnions: false,
+            validJson: true,
+            refs: true,
+            unions: true,
+            formats: true,
+            toolNameLength: undefined,
+        };
+        const transformed = (0, compat_1.applyCompatibilityTransformations)(endpoints, capabilities);
+        expect(transformed.length).toBe(2);
+        expect(transformed[0].tool.name).toBe('union-tool_first_variant');
+        expect(transformed[1].tool.name).toBe('union-tool_second_variant');
+    });
+    it('should handle variants without titles in removeTopLevelUnions', () => {
+        const tool = createTestTool('union-tool', {
+            inputSchema: {
+                type: 'object',
+                properties: {
+                    common: { type: 'string' },
+                },
+                anyOf: [
+                    {
+                        properties: {
+                            variant1: { type: 'string' },
+                        },
+                    },
+                    {
+                        properties: {
+                            variant2: { type: 'number' },
+                        },
+                    },
+                ],
+            },
+        });
+        const endpoints = [createTestEndpoint(tool)];
+        const capabilities = {
+            topLevelUnions: false,
+            validJson: true,
+            refs: true,
+            unions: true,
+            formats: true,
+            toolNameLength: undefined,
+        };
+        const transformed = (0, compat_1.applyCompatibilityTransformations)(endpoints, capabilities);
+        expect(transformed.length).toBe(2);
+        expect(transformed[0].tool.name).toBe('union-tool_variant1');
+        expect(transformed[1].tool.name).toBe('union-tool_variant2');
+    });
+    it('should truncate tool names when toolNameLength is set', () => {
+        const tools = [
+            createTestTool('very-long-tool-name-that-exceeds-limit'),
+            createTestTool('another-long-tool-name-to-truncate'),
+            createTestTool('short-name'),
+        ];
+        const endpoints = tools.map(createTestEndpoint);
+        const capabilities = {
+            topLevelUnions: true,
+            validJson: true,
+            refs: true,
+            unions: true,
+            formats: true,
+            toolNameLength: 20,
+        };
+        const transformed = (0, compat_1.applyCompatibilityTransformations)(endpoints, capabilities);
+        expect(transformed[0].tool.name).toBe('very-long-tool-name-');
+        expect(transformed[1].tool.name).toBe('another-long-tool-na');
+        expect(transformed[2].tool.name).toBe('short-name');
+    });
+    it('should inline refs when refs capability is disabled', () => {
+        const tool = createTestTool('ref-tool', {
+            inputSchema: {
+                type: 'object',
+                properties: {
+                    user: { $ref: '#/$defs/user' },
+                },
+                $defs: {
+                    user: {
+                        type: 'object',
+                        properties: {
+                            name: { type: 'string' },
+                            email: { type: 'string' },
+                        },
+                    },
+                },
+            },
+        });
+        const endpoints = [createTestEndpoint(tool)];
+        const capabilities = {
+            topLevelUnions: true,
+            validJson: true,
+            refs: false,
+            unions: true,
+            formats: true,
+            toolNameLength: undefined,
+        };
+        const transformed = (0, compat_1.applyCompatibilityTransformations)(endpoints, capabilities);
+        const schema = transformed[0].tool.inputSchema;
+        expect(schema.$defs).toBeUndefined();
+        if (schema.properties) {
+            expect(schema.properties['user']).toEqual({
+                type: 'object',
+                properties: {
+                    name: { type: 'string' },
+                    email: { type: 'string' },
+                },
+            });
+        }
+    });
+    it('should preserve external refs when inlining', () => {
+        const tool = createTestTool('ref-tool', {
+            inputSchema: {
+                type: 'object',
+                properties: {
+                    internal: { $ref: '#/$defs/internal' },
+                    external: { $ref: 'https://example.com/schemas/external.json' },
+                },
+                $defs: {
+                    internal: {
+                        type: 'object',
+                        properties: {
+                            name: { type: 'string' },
+                        },
+                    },
+                },
+            },
+        });
+        const endpoints = [createTestEndpoint(tool)];
+        const capabilities = {
+            topLevelUnions: true,
+            validJson: true,
+            refs: false,
+            unions: true,
+            formats: true,
+            toolNameLength: undefined,
+        };
+        const transformed = (0, compat_1.applyCompatibilityTransformations)(endpoints, capabilities);
+        const schema = transformed[0].tool.inputSchema;
+        if (schema.properties) {
+            expect(schema.properties['internal']).toEqual({
+                type: 'object',
+                properties: {
+                    name: { type: 'string' },
+                },
+            });
+            expect(schema.properties['external']).toEqual({
+                $ref: 'https://example.com/schemas/external.json',
+            });
+        }
+    });
+    it('should remove anyOf fields when unions capability is disabled', () => {
+        const tool = createTestTool('union-tool', {
+            inputSchema: {
+                type: 'object',
+                properties: {
+                    field: {
+                        anyOf: [{ type: 'string' }, { type: 'number' }],
+                    },
+                },
+            },
+        });
+        const endpoints = [createTestEndpoint(tool)];
+        const capabilities = {
+            topLevelUnions: true,
+            validJson: true,
+            refs: true,
+            unions: false,
+            formats: true,
+            toolNameLength: undefined,
+        };
+        const transformed = (0, compat_1.applyCompatibilityTransformations)(endpoints, capabilities);
+        const schema = transformed[0].tool.inputSchema;
+        if (schema.properties && schema.properties['field']) {
+            const field = schema.properties['field'];
+            expect(field.anyOf).toBeUndefined();
+            expect(field.type).toBe('string');
+        }
+    });
+    it('should correctly combine topLevelUnions and toolNameLength transformations', () => {
+        const tool = createTestTool('very-long-union-tool-name', {
+            inputSchema: {
+                type: 'object',
+                properties: {
+                    common: { type: 'string' },
+                },
+                anyOf: [
+                    {
+                        title: 'first variant',
+                        properties: {
+                            variant1: { type: 'string' },
+                        },
+                    },
+                    {
+                        title: 'second variant',
+                        properties: {
+                            variant2: { type: 'number' },
+                        },
+                    },
+                ],
+            },
+        });
+        const endpoints = [createTestEndpoint(tool)];
+        const capabilities = {
+            topLevelUnions: false,
+            validJson: true,
+            refs: true,
+            unions: true,
+            formats: true,
+            toolNameLength: 20,
+        };
+        const transformed = (0, compat_1.applyCompatibilityTransformations)(endpoints, capabilities);
+        expect(transformed.length).toBe(2);
+        // Both names should be truncated because they exceed 20 characters
+        expect(transformed[0].tool.name).toBe('very-long-union-too1');
+        expect(transformed[1].tool.name).toBe('very-long-union-too2');
+    });
+    it('should correctly combine refs and unions transformations', () => {
+        const tool = createTestTool('complex-tool', {
+            inputSchema: {
+                type: 'object',
+                properties: {
+                    user: { $ref: '#/$defs/user' },
+                },
+                $defs: {
+                    user: {
+                        type: 'object',
+                        properties: {
+                            preference: {
+                                anyOf: [{ type: 'string' }, { type: 'number' }],
+                            },
+                        },
+                    },
+                },
+            },
+        });
+        const endpoints = [createTestEndpoint(tool)];
+        const capabilities = {
+            topLevelUnions: true,
+            validJson: true,
+            refs: false,
+            unions: false,
+            formats: true,
+            toolNameLength: undefined,
+        };
+        const transformed = (0, compat_1.applyCompatibilityTransformations)(endpoints, capabilities);
+        const schema = transformed[0].tool.inputSchema;
+        // Refs should be inlined
+        expect(schema.$defs).toBeUndefined();
+        // Safely access nested properties
+        if (schema.properties && schema.properties['user']) {
+            const user = schema.properties['user'];
+            // User should be inlined
+            expect(user.type).toBe('object');
+            // AnyOf in the inlined user.preference should be removed
+            if (user.properties && user.properties['preference']) {
+                const preference = user.properties['preference'];
+                expect(preference.anyOf).toBeUndefined();
+                expect(preference.type).toBe('string');
+            }
+        }
+    });
+    it('should handle formats capability being false', () => {
+        const tool = createTestTool('format-tool', {
+            inputSchema: {
+                type: 'object',
+                properties: {
+                    date: { type: 'string', description: 'A date', format: 'date' },
+                },
+            },
+        });
+        const endpoints = [createTestEndpoint(tool)];
+        const capabilities = {
+            topLevelUnions: true,
+            validJson: true,
+            refs: true,
+            unions: true,
+            formats: false,
+            toolNameLength: undefined,
+        };
+        const transformed = (0, compat_1.applyCompatibilityTransformations)(endpoints, capabilities);
+        const schema = transformed[0].tool.inputSchema;
+        if (schema.properties && schema.properties['date']) {
+            const dateField = schema.properties['date'];
+            expect(dateField['format']).toBeUndefined();
+            expect(dateField['description']).toBe('A date (format: "date")');
+        }
+    });
+});
+//# sourceMappingURL=compat.test.js.map