fix: resolve $ref siblings defensively, preserve property names definitions/$defs

Address review feedback from PR #1563:

1. Defensive: resolve sibling values through resolve() before merging
   onto the resolved $ref schema. No known generator triggers this
   (Zod/ArkType/Valibot only produce metadata siblings), but it makes
   the sibling-merge and object-traversal paths consistent.

2. Bug fix: only strip $defs/definitions keys at the root schema level.
   Previously the filter fired at every depth, silently dropping any
   property named 'definitions' or '$defs' from nested objects.

Tests added for both fixes.

Author: gogakoreli

packages/core/src/util/schema.ts

@@ -102,14 +102,15 @@ export function dereferenceLocalRefs(schema: Record<string, unknown>): Record<st
 
             // Merge sibling keywords onto the resolved schema
             if (hasSiblings && resolved !== null && typeof resolved === 'object' && !Array.isArray(resolved)) {
-                return { ...(resolved as Record<string, unknown>), ...siblings };
+                const resolvedSiblings = Object.fromEntries(Object.entries(siblings).map(([k, v]) => [k, resolve(v, stack)]));
+                return { ...(resolved as Record<string, unknown>), ...resolvedSiblings };
             }
             return resolved;
         }
 
         const result: Record<string, unknown> = {};
         for (const [key, value] of Object.entries(obj)) {
-            if (key === '$defs' || key === 'definitions') continue;
+            if (obj === schema && (key === '$defs' || key === 'definitions')) continue;
             result[key] = resolve(value, stack);
         }
         return result;

packages/core/test/schema.test.ts

@@ -196,4 +196,55 @@ describe('dereferenceLocalRefs', () => {
         expect(hq['type']).toBe('object');
         expect(hq['properties']).toEqual({ street: { type: 'string' } });
     });
+
+    // Defensive: hand-crafted synthetic schema — no known schema generator (Zod v4,
+    // ArkType, Valibot) produces $ref with a sibling containing nested $ref.
+    // Generators put $ref inside allOf/anyOf/oneOf array elements (resolved by
+    // array recursion), not as siblings of $ref on the same node.
+    // See: https://github.com/modelcontextprotocol/typescript-sdk/pull/1563#discussion_r3022304127
+    test('$ref siblings containing nested $ref are resolved (defensive)', () => {
+        const schema = {
+            type: 'object',
+            properties: { x: { $ref: '#/$defs/Outer' } },
+            $defs: {
+                Outer: { $ref: '#/$defs/Inner', allOf: [{ $ref: '#/$defs/Mixin' }] },
+                Inner: { type: 'object' },
+                Mixin: { title: 'mixin' }
+            }
+        };
+        const result = dereferenceLocalRefs(schema);
+        expect(JSON.stringify(result)).not.toContain('$ref');
+        expect(JSON.stringify(result)).not.toContain('$defs');
+        const x = (result['properties'] as Record<string, Record<string, unknown>>)['x']!;
+        expect(x['type']).toBe('object');
+        expect(x['allOf']).toEqual([{ title: 'mixin' }]);
+    });
+
+    test('property named "definitions" is not stripped from nested objects', () => {
+        const schema = {
+            type: 'object',
+            properties: {
+                items: { type: 'array', items: { type: 'string' } },
+                definitions: { type: 'array', items: { type: 'string' } }
+            },
+            required: ['items', 'definitions']
+        };
+        const result = dereferenceLocalRefs(schema);
+        const props = result['properties'] as Record<string, unknown>;
+        expect(props['definitions']).toEqual({ type: 'array', items: { type: 'string' } });
+        expect(props['items']).toEqual({ type: 'array', items: { type: 'string' } });
+    });
+
+    test('property named "$defs" is not stripped from nested objects', () => {
+        const schema = {
+            type: 'object',
+            properties: {
+                name: { type: 'string' },
+                $defs: { type: 'object', properties: { x: { type: 'number' } } }
+            }
+        };
+        const result = dereferenceLocalRefs(schema);
+        const props = result['properties'] as Record<string, unknown>;
+        expect(props['$defs']).toEqual({ type: 'object', properties: { x: { type: 'number' } } });
+    });
 });