fix: add json schema transformation logic

package.json

@@ -54,7 +54,7 @@
     "tslib": "^2.8.1",
     "typescript": "5.8.3",
     "ws": "^8.18.0",
-    "zod": "^3.25 || ^4.0",
+    "zod": "^3.25 || ^4.1.13",
     "typescript-eslint": "8.31.1"
   },
   "bin": {

src/helpers/zod.ts

@@ -14,28 +14,33 @@ import { AutoParseableResponseTool, makeParseableResponseTool } from '../lib/Res
 import { type ResponseFormatTextJSONSchemaConfig } from '../resources/responses/responses';
 import { toStrictJsonSchema } from '../lib/transform';
 import { JSONSchema } from '../lib/jsonschema';
+import { transformJSONSchema } from '../lib/transform-json-schema';
 
 type InferZodType<T> =
   T extends z4.ZodType ? z4.infer<T>
   : T extends z3.ZodType ? z3.infer<T>
   : never;
 
 function zodV3ToJsonSchema(schema: z3.ZodType, options: { name: string }): Record<string, unknown> {
-  return _zodToJsonSchema(schema, {
-    openaiStrictMode: true,
-    name: options.name,
-    nameStrategy: 'duplicate-ref',
-    $refStrategy: 'extract-to-root',
-    nullableStrategy: 'property',
-  });
+  return transformJSONSchema(
+    _zodToJsonSchema(schema, {
+      openaiStrictMode: true,
+      name: options.name,
+      nameStrategy: 'duplicate-ref',
+      $refStrategy: 'extract-to-root',
+      nullableStrategy: 'property',
+    }),
+  );
 }
 
 function zodV4ToJsonSchema(schema: z4.ZodType): Record<string, unknown> {
-  return toStrictJsonSchema(
-    z4.toJSONSchema(schema, {
-      target: 'draft-7',
-    }) as JSONSchema,
-  ) as Record<string, unknown>;
+  return transformJSONSchema(
+    toStrictJsonSchema(
+      z4.toJSONSchema(schema, {
+        target: 'draft-7',
+      }) as JSONSchema,
+    ) as Record<string, unknown>,
+  );
 }
 
 function isZodV4(zodObject: z3.ZodType | z4.ZodType): zodObject is z4.ZodType {

src/internal/transform-json-schema.ts

@@ -0,0 +1,85 @@
+import type { JSONSchema } from '../lib/jsonschema';
+import { pop } from '../internal/utils';
+
+function deepClone<T>(obj: T): T {
+  return JSON.parse(JSON.stringify(obj));
+}
+
+export function transformJSONSchema(jsonSchema: JSONSchema): JSONSchema {
+  const workingCopy = deepClone(jsonSchema);
+  return _transformJSONSchema(workingCopy);
+}
+
+function _transformJSONSchema(jsonSchema: JSONSchema): JSONSchema {
+  if (typeof jsonSchema !== 'object' || jsonSchema === null) {
+    // e.g. base case for additionalProperties
+    return jsonSchema;
+  }
+
+  const defs = pop(jsonSchema, '$defs');
+  if (defs !== undefined) {
+    const strictDefs: Record<string, JSONSchema> = {};
+    jsonSchema.$defs = strictDefs;
+    for (const [name, defSchema] of Object.entries(defs)) {
+      strictDefs[name] = _transformJSONSchema(defSchema as JSONSchema);
+    }
+  }
+
+  const type = jsonSchema.type;
+  const anyOf = pop(jsonSchema, 'anyOf');
+  const oneOf = pop(jsonSchema, 'oneOf');
+  const allOf = pop(jsonSchema, 'allOf');
+  const not = pop(jsonSchema, 'not');
+
+  const shouldHaveType = [anyOf, oneOf, allOf, not].some(Array.isArray);
+  if (!shouldHaveType && type === undefined) {
+    throw new Error('JSON schema must have a type defined if anyOf/oneOf/allOf are not used');
+  }
+
+  if (Array.isArray(anyOf)) {
+    jsonSchema.anyOf = anyOf.map((variant) => _transformJSONSchema(variant as JSONSchema));
+  }
+
+  if (Array.isArray(oneOf)) {
+    // replace all oneOfs to anyOf
+    jsonSchema.anyOf = oneOf.map((variant) => _transformJSONSchema(variant as JSONSchema));
+    delete jsonSchema.oneOf;
+  }
+
+  if (Array.isArray(allOf)) {
+    jsonSchema.allOf = allOf.map((entry) => _transformJSONSchema(entry as JSONSchema));
+  }
+
+  if (not !== undefined) {
+    jsonSchema.not = _transformJSONSchema(not as JSONSchema);
+  }
+
+  const additionalProperties = pop(jsonSchema, 'additionalProperties');
+  if (additionalProperties !== undefined) {
+    jsonSchema.additionalProperties = _transformJSONSchema(additionalProperties as JSONSchema);
+  }
+
+  switch (type) {
+    case 'object': {
+      const properties = pop(jsonSchema, 'properties');
+      if (properties !== undefined) {
+        jsonSchema.properties = Object.fromEntries(
+          Object.entries(properties).map(([key, propSchema]) => [
+            key,
+            _transformJSONSchema(propSchema as JSONSchema),
+          ]),
+        );
+      }
+      break;
+    }
+    case 'array': {
+      const items = pop(jsonSchema, 'items');
+      if (items !== undefined) {
+        jsonSchema.items = _transformJSONSchema(items as JSONSchema);
+      }
+      break;
+    }
+  }
+
+  return jsonSchema;
+}

src/internal/utils/values.ts

@@ -103,3 +103,10 @@ export const safeJSON = (text: string) => {
     return undefined;
   }
 };
+
+// Gets a value from an object, deletes the key, and returns the value (or undefined if not found)
+export const pop = <T extends Record<string, any>, K extends string>(obj: T, key: K): T[K] => {
+  const value = obj[key];
+  delete obj[key];
+  return value;
+};

tests/helpers/transform-json-schema.test.ts

@@ -0,0 +1,204 @@
+import { transformJSONSchema } from '../../src/internal/transform-json-schema';
+
+describe('transformJsonSchema', () => {
+  it('should not mutate the original schema', () => {
+    const input = {
+      type: 'object',
+      properties: {
+        bonus: {
+          type: 'integer',
+          default: 100000,
+          minimum: 100000,
+          title: 'Bonus',
+          description: 'Annual bonus in USD',
+        },
+        tags: {
+          type: 'array',
+          items: { type: 'string' },
+          minItems: 3,
+        },
+      },
+      title: 'Employee',
+      additionalProperties: true,
+    };
+
+    const inputCopy = JSON.parse(JSON.stringify(input));
+
+    transformJSONSchema(input);
+
+    expect(input).toEqual(inputCopy);
+  });
+
+  it('should turn a discriminated union oneOf into an anyOf', () => {
+    const input = {
+      type: 'object',
+      oneOf: [
+        {
+          type: 'object',
+          properties: {
+            bonus: {
+              type: 'integer',
+            },
+          },
+        },
+        {
+          type: 'object',
+          properties: {
+            salary: {
+              type: 'integer',
+            },
+          },
+        },
+      ],
+    };
+
+    const expected = {
+      type: 'object',
+      anyOf: [
+        {
+          type: 'object',
+          properties: {
+            bonus: {
+              type: 'integer',
+            },
+          },
+        },
+        {
+          type: 'object',
+          properties: {
+            salary: {
+              type: 'integer',
+            },
+          },
+        },
+      ],
+    };
+
+    const transformedSchema = transformJSONSchema(input);
+
+    expect(transformedSchema).toEqual(expected);
+  });
+
+  it('should turn oneOf into anyOf in recursive object in list', () => {
+    const input = {
+      type: 'object',
+      properties: {
+        employees: {
+          type: 'array',
+          items: {
+            type: 'object',
+            oneOf: [
+              {
+                type: 'object',
+                properties: {
+                  bonus: {
+                    type: 'integer',
+                  },
+                },
+              },
+              {
+                type: 'object',
+                properties: {
+                  salary: {
+                    type: 'integer',
+                  },
+                },
+              },
+            ],
+          },
+        },
+      },
+    };
+
+    const expected = {
+      type: 'object',
+      properties: {
+        employees: {
+          type: 'array',
+          items: {
+            type: 'object',
+            anyOf: [
+              {
+                type: 'object',
+                properties: {
+                  bonus: {
+                    type: 'integer',
+                  },
+                },
+              },
+              {
+                type: 'object',
+                properties: {
+                  salary: {
+                    type: 'integer',
+                  },
+                },
+              },
+            ],
+          },
+        },
+      },
+    };
+
+    const transformedSchema = transformJSONSchema(input);
+
+    expect(transformedSchema).toEqual(expected);
+  });
+
+  it('throws when not anyOf/oneOf/allOf and type not defined', () => {
+    const input = {
+      type: 'object',
+      properties: {
+        employees: {
+          type: 'array',
+          items: {
+            properties: {
+              bonus: {
+                type: 'integer',
+              },
+            },
+          },
+        },
+      },
+    };
+
+    expect(() => transformJSONSchema(input)).toThrow(
+      'JSON schema must have a type defined if anyOf/oneOf/allOf are not used',
+    );
+  });
+
+  it('should preserve additionalProperties recursively', () => {
+    const input = {
+      type: 'object',
+      properties: {
+        employees: {
+          type: 'array',
+          items: {
+            type: 'object',
+            properties: {
+              name: { type: 'string' },
+              metadata: {
+                type: 'object',
+                properties: {
+                  id: { type: 'string' },
+                },
+                additionalProperties: {
+                  type: 'string',
+                  maxLength: 100,
+                },
+              },
+            },
+            additionalProperties: true,
+          },
+        },
+      },
+      additionalProperties: false,
+    };
+
+    const expected = structuredClone(input);
+
+    const transformedSchema = transformJSONSchema(input);
+
+    expect(transformedSchema).toEqual(expected);
+  });
+});