1
import { describe, it, expect, vi } from 'vitest';
2
-import { dereferenceJsonSchema } from '../../src/utils/jsonSchema';
2
+import {
3
+ deduplicateJsonSchemaRequiredArrays,
4
+ dereferenceJsonSchema,
5
+} from '../../src/utils/jsonSchema';
6
import { JsonSchemaRefResolutionError } from '../../src/errors/ValidationErrors';
7
import logger from '../../src/utils/logger';
8
+import { ToolSchema } from '../../src/types/tool.types';
9
10
const containsRef = (value: unknown): boolean => {
11
if (value === null || typeof value !== 'object') return false;
488
});
489
});
490
});
491
+
492
+describe('deduplicateJsonSchemaRequiredArrays', () => {
493
+ it('deduplicates every required array without mutating the input schema', () => {
494
+ const schema = {
495
+ type: 'object',
496
+ required: ['owner', 'name', 'owner'],
497
+ properties: {
498
+ options: {
499
+ type: 'object',
500
+ required: ['enabled', 'enabled'],
501
+ properties: { enabled: { type: 'boolean' } },
502
+ },
503
+ },
504
+ };
505
+
506
+ const normalized = deduplicateJsonSchemaRequiredArrays(schema);
507
+
508
+ expect(normalized).toEqual({
509
+ type: 'object',
510
+ required: ['owner', 'name'],
511
+ properties: {
512
+ options: {
513
+ type: 'object',
514
+ required: ['enabled'],
515
+ properties: { enabled: { type: 'boolean' } },
516
+ },
517
+ },
518
+ });
519
+ expect(schema.required).toEqual(['owner', 'name', 'owner']);
520
+ expect(schema.properties.options.required).toEqual(['enabled', 'enabled']);
521
+ });
522
+
523
+ it('does not normalize literal instance values', () => {
524
+ const sharedValue = {
525
+ type: 'object',
526
+ required: ['preserve', 'preserve'],
527
+ properties: { preserve: { type: 'string' } },
528
+ };
529
+ const schema = {
530
+ type: 'object',
531
+ required: ['value', 'value'],
532
+ properties: {
533
+ schemaValue: sharedValue,
534
+ value: {
535
+ const: sharedValue,
536
+ default: { required: ['preserve', 'preserve'] },
537
+ enum: [{ required: ['preserve', 'preserve'] }],
538
+ examples: [{ required: ['preserve', 'preserve'] }],
539
+ },
540
+ },
541
+ };
542
+
543
+ const normalized = deduplicateJsonSchemaRequiredArrays(schema);
544
+
545
+ expect(normalized).toMatchObject({
546
+ required: ['value'],
547
+ properties: {
548
+ schemaValue: { required: ['preserve'] },
549
+ value: {
550
+ const: { required: ['preserve', 'preserve'] },
551
+ default: { required: ['preserve', 'preserve'] },
552
+ enum: [{ required: ['preserve', 'preserve'] }],
553
+ examples: [{ required: ['preserve', 'preserve'] }],
554
+ },
555
+ },
556
+ });
557
+ expect(normalized.properties.value.const).not.toBe(schema.properties.value.const);
558
+ });
559
+
560
+ it('fails predictably for schemas nested beyond the supported depth', () => {
561
+ const defaultValue: Record<string, unknown> = {};
562
+ let cursor = defaultValue;
563
+ for (let i = 0; i <= 512; i++) {
564
+ cursor.child = {};
565
+ cursor = cursor.child as Record<string, unknown>;
566
+ }
567
+
568
+ expect(() =>
569
+ deduplicateJsonSchemaRequiredArrays({
570
+ type: 'object',
571
+ properties: { value: { default: defaultValue } },
572
+ })
573
+ ).toThrow('JSON Schema exceeds maximum nesting depth of 512');
574
+ });
575
+
576
+ it('normalizes schemas at the shared ToolSchema API boundary', () => {
577
+ const tool = ToolSchema.parse({
578
+ slug: 'TEST_TOOL',
579
+ name: 'Test tool',
580
+ inputParameters: {
581
+ type: 'object',
582
+ required: ['name', 'name'],
583
+ properties: {
584
+ name: { type: 'string' },
585
+ options: {
586
+ type: 'object',
587
+ required: ['enabled', 'enabled'],
588
+ properties: { enabled: { type: 'boolean' } },
589
+ },
590
+ },
591
+ },
592
+ });
593
+
594
+ expect(tool.inputParameters?.required).toEqual(['name']);
595
+ expect(tool.inputParameters?.properties.options.required).toEqual(['enabled']);
596
+ });
597
+});