openai 7.4.0 → 7.5.0

package/lib/transform.js

@@ -7,6 +7,7 @@ exports.hasOnlyRefAndAnnotations = hasOnlyRefAndAnnotations;
 exports.assertNoNestedSchemaIds = assertNoNestedSchemaIds;
 exports.rewriteLocalRefsIntoMovedOneOfBranches = rewriteLocalRefsIntoMovedOneOfBranches;
 exports.normalizeObjectAllOfForExclusivity = normalizeObjectAllOfForExclusivity;
+const utils_1 = require("../internal/utils.js");
 const JSON_SCHEMA_ANNOTATION_KEYWORDS = new Set([
     '$comment',
     'default',
@@ -85,6 +86,21 @@ const MERGEABLE_OBJECT_ALL_OF_KEYWORDS = new Set([
     'required',
     'type',
 ]);
+/** Assigns schema keywords without invoking the inherited `__proto__` setter. */
+function assignSchema(target, ...sources) {
+    for (const source of sources) {
+        if (Object.prototype.propertyIsEnumerable.call(source, '__proto__') && !(0, utils_1.hasOwn)(target, '__proto__')) {
+            Object.defineProperty(target, '__proto__', {
+                value: undefined,
+                writable: true,
+                enumerable: true,
+                configurable: true,
+            });
+        }
+        Object.assign(target, source);
+    }
+    return target;
+}
 /**
  * Visits only values carried by JSON Schema keywords that contain schemas.
  * Literal payloads such as enum, const, and default deliberately do not
@@ -110,17 +126,27 @@ function forEachJSONSchemaChild(schema, path, visit) {
     }
     for (const keyword of JSON_SCHEMA_MAP_SCHEMA_KEYWORDS) {
         const children = record[keyword];
-        if (!isObject(children))
+        if (!isObject(children)) {
             continue;
+        }
         for (const [key, child] of Object.entries(children)) {
             // Draft 7 dependencies also permits property dependency arrays. They
             // are not schemas and must not be traversed as literal JSON payloads.
-            if (keyword === 'dependencies' && !isSchemaDefinition(child))
+            if (keyword === 'dependencies' && !isSchemaDefinition(child)) {
                 continue;
+            }
             visit(child, [...path, keyword, key], keyword);
         }
     }
 }
+/**
+ * Returns a cloned schema normalized for strict Structured Outputs.
+ *
+ * Object properties become required, object schemas are closed to additional
+ * properties, and representable local references and intersections are preserved.
+ *
+ * @throws {Error} If the schema cannot be represented without changing its validation semantics.
+ */
 function toStrictJsonSchema(schema) {
     const schemaCopy = structuredClone(schema);
     // JSON serialization omits undefined object properties. Drop optional
@@ -261,7 +287,7 @@ function inlineRootRefObject(schema) {
     for (const keyword of Object.keys(schema)) {
         delete schemaRecord[keyword];
     }
-    Object.assign(schema, inlined, inheritedAnnotations, rootMetadata);
+    assignSchema(schema, inlined, inheritedAnnotations, rootMetadata);
     if (rootDefinitions !== undefined) {
         schema.$defs = rootDefinitions;
     }
@@ -305,7 +331,7 @@ function normalizeRootAllOf(schema) {
         for (const keyword of Object.keys(schema)) {
             delete schemaRecord[keyword];
         }
-        Object.assign(schema, normalized, rootMetadata);
+        assignSchema(schema, normalized, rootMetadata);
     }
 }
 /**
@@ -346,7 +372,12 @@ function normalizeRootAnyOf(schema) {
         const renames = definitionRenames.get(keyword);
         const mergedDefinitions = { ...rootDefinitions };
         for (const [name, definition] of Object.entries(branchDefinitions)) {
-            mergedDefinitions[renames?.get(name) ?? name] = definition;
+            Object.defineProperty(mergedDefinitions, renames?.get(name) ?? name, {
+                value: definition,
+                writable: true,
+                enumerable: true,
+                configurable: true,
+            });
         }
         normalized[keyword] = mergedDefinitions;
         delete rootMetadata[keyword];
@@ -355,7 +386,7 @@ function normalizeRootAnyOf(schema) {
     for (const keyword of Object.keys(schema)) {
         delete schemaRecord[keyword];
     }
-    Object.assign(schema, normalized, rootMetadata);
+    assignSchema(schema, normalized, rootMetadata);
     return true;
 }
 /**
@@ -375,8 +406,7 @@ function planPromotedRootAnyOfDefinitionRenames(root, branch) {
         const keywordRenames = new Map();
         let aliasIndex = 0;
         for (const [name, definition] of Object.entries(branchDefinitions)) {
-            if (!Object.prototype.hasOwnProperty.call(rootDefinitions, name) ||
-                schemasEqual(rootDefinitions[name], definition)) {
+            if (!(0, utils_1.hasOwn)(rootDefinitions, name) || schemasEqual(rootDefinitions[name], definition)) {
                 continue;
             }
             let alias = '__openai_strict_anyOf_definition_' + aliasIndex++;
@@ -411,8 +441,8 @@ function rewriteLocalRefsIntoPromotedRootAnyOfBranch(root, branchIndex, definiti
                 promotedParts[1] = renamed;
             }
         }
-        return promotedParts.length === 0 ?
-            '#'
+        return promotedParts.length === 0
+            ? '#'
             : '#/' + promotedParts.map(encodeJSONPointerTokenForURIFragment).join('/');
     };
     const rewriteRefs = (value) => {
@@ -490,21 +520,17 @@ function isNullable(schema, root, seenRefs = new Set()) {
     if (schema.enum !== undefined && (!Array.isArray(schema.enum) || !schema.enum.includes(null))) {
         return false;
     }
-    if (schema.allOf !== undefined) {
-        if (!Array.isArray(schema.allOf) || !schema.allOf.every((variant) => isNullable(variant, root))) {
-            return false;
-        }
+    if (schema.allOf !== undefined &&
+        (!Array.isArray(schema.allOf) || !schema.allOf.every((variant) => isNullable(variant, root)))) {
+        return false;
     }
-    if (schema.anyOf !== undefined) {
-        if (!Array.isArray(schema.anyOf) || !schema.anyOf.some((variant) => isNullable(variant, root))) {
-            return false;
-        }
+    if (schema.anyOf !== undefined &&
+        (!Array.isArray(schema.anyOf) || !schema.anyOf.some((variant) => isNullable(variant, root)))) {
+        return false;
     }
-    if (schema.oneOf !== undefined) {
-        if (!Array.isArray(schema.oneOf) ||
-            schema.oneOf.filter((variant) => isNullable(variant, root)).length !== 1) {
-            return false;
-        }
+    if (schema.oneOf !== undefined &&
+        (!Array.isArray(schema.oneOf) || schema.oneOf.filter((variant) => isNullable(variant, root)).length !== 1)) {
+        return false;
     }
     // Conditional and negated schemas need a full JSON Schema evaluator to prove
     // that null is allowed. Treat them conservatively instead of accepting an
@@ -552,7 +578,7 @@ function ensureStrictJsonSchema(jsonSchema, path, root) {
     // the same strict handling as type: 'object'. Explicitly open object schemas
     // cannot be represented in Structured Outputs strict mode.
     if (hasObjectShape(jsonSchema)) {
-        if (!('additionalProperties' in jsonSchema)) {
+        if (!(0, utils_1.hasOwn)(jsonSchema, 'additionalProperties')) {
             jsonSchema.additionalProperties = false;
         }
         else if (jsonSchema.additionalProperties !== false) {
@@ -567,7 +593,7 @@ function ensureStrictJsonSchema(jsonSchema, path, root) {
     const properties = jsonSchema.properties;
     if (hasObjectShape(jsonSchema)) {
         for (const key of required) {
-            if (!isObject(properties) || !Object.prototype.hasOwnProperty.call(properties, key)) {
+            if (!isObject(properties) || !(0, utils_1.hasOwn)(properties, key)) {
                 throw new Error(`Object schema at \`${path.join('/') || '<root>'}\` requires property \`${key}\` but does not declare it in \`properties\`.`);
             }
         }
@@ -586,31 +612,29 @@ function ensureStrictJsonSchema(jsonSchema, path, root) {
     const items = jsonSchema.items;
     const additionalItems = jsonSchema.additionalItems;
     if (Array.isArray(items)) {
-        throw new Error(`Schema at \`${path.join('/') || '<root>'}\` uses tuple-form \`items\`, which cannot be represented in strict Structured Outputs.`);
+        throw new TypeError(`Schema at \`${path.join('/') || '<root>'}\` uses tuple-form \`items\`, which cannot be represented in strict Structured Outputs.`);
     }
     if (additionalItems !== undefined) {
         throw new Error(`Schema at \`${path.join('/') || '<root>'}\` uses unsupported keyword \`additionalItems\` and cannot be represented in strict Structured Outputs.`);
     }
     // Handle intersections (allOf)
     const allOf = jsonSchema.allOf;
-    if (Array.isArray(allOf)) {
-        if (allOf.length === 1 && hasOnlyAnnotationSiblings(jsonSchema, 'allOf')) {
-            const branch = allOf[0];
-            if (branch === false) {
-                throw new Error(`Schema at \`${path.join('/') || '<root>'}\` uses \`allOf: [false]\`, which cannot be represented in strict Structured Outputs.`);
-            }
-            if (branch === true) {
-                // true is the neutral schema for an intersection, so removing this
-                // branch preserves validation while retaining the parent annotations.
-                delete jsonSchema.allOf;
-            }
-            else {
-                const resolved = ensureStrictJsonSchema(branch, [...path, 'allOf', '0'], root);
-                const annotations = { ...jsonSchema };
-                delete annotations.allOf;
-                Object.assign(jsonSchema, resolved, annotations);
-                delete jsonSchema.allOf;
-            }
+    if (Array.isArray(allOf) && allOf.length === 1 && hasOnlyAnnotationSiblings(jsonSchema, 'allOf')) {
+        const branch = allOf[0];
+        if (branch === false) {
+            throw new Error(`Schema at \`${path.join('/') || '<root>'}\` uses \`allOf: [false]\`, which cannot be represented in strict Structured Outputs.`);
+        }
+        if (branch === true) {
+            // true is the neutral schema for an intersection, so removing this
+            // branch preserves validation while retaining the parent annotations.
+            delete jsonSchema.allOf;
+        }
+        else {
+            const resolved = ensureStrictJsonSchema(branch, [...path, 'allOf', '0'], root);
+            const annotations = { ...jsonSchema };
+            delete annotations.allOf;
+            assignSchema(jsonSchema, resolved, annotations);
+            delete jsonSchema.allOf;
         }
     }
     normalizeArrayUnionWrapper(jsonSchema, root);
@@ -682,16 +706,22 @@ function resolvePointerPart(resolved, part) {
             return undefined;
         }
         const index = Number(part);
-        if (!Object.prototype.hasOwnProperty.call(resolved, index)) {
+        if (!(0, utils_1.hasOwn)(resolved, index)) {
             return undefined;
         }
         return resolved[index];
     }
-    if (!isObject(resolved) || !Object.prototype.hasOwnProperty.call(resolved, part)) {
+    if (!isObject(resolved) || !(0, utils_1.hasOwn)(resolved, part)) {
         return undefined;
     }
     return resolved[part];
 }
+/**
+ * Resolves a local JSON Pointer through schema-bearing keywords only.
+ *
+ * Returns `undefined` for external references, malformed pointers, missing
+ * targets, and pointers into literal values such as `default` or `enum`.
+ */
 function resolveLocalRef(root, ref) {
     const parts = parseLocalRef(ref);
     if (parts === undefined) {
@@ -769,8 +799,8 @@ function isObjectOnlySchema(schema, root, seenRefs = new Set()) {
             return false;
         }
         const branch = schema.allOf[0];
-        return branch !== undefined && branch !== true && branch !== false ?
-            isObjectOnlySchema(branch, root, seenRefs)
+        return branch !== undefined && branch !== true && branch !== false
+            ? isObjectOnlySchema(branch, root, seenRefs)
             : false;
     }
     return (schema.type === 'object' ||
@@ -797,13 +827,14 @@ function isArrayOnlySchema(schema, root, seenRefs = new Set()) {
             return false;
         }
         const branch = schema.allOf[0];
-        return branch !== undefined && branch !== true && branch !== false ?
-            isArrayOnlySchema(branch, root, seenRefs)
+        return branch !== undefined && branch !== true && branch !== false
+            ? isArrayOnlySchema(branch, root, seenRefs)
             : false;
     }
     return (schema.type === 'array' ||
         (Array.isArray(schema.type) && schema.type.length === 1 && schema.type[0] === 'array'));
 }
+/** Returns whether a schema contains only a reference, reusable definitions, and annotations. */
 function hasOnlyRefAndAnnotations(schema) {
     return Object.keys(schema).every(
     // Definition maps do not add sibling validation constraints, and keeping
@@ -902,6 +933,11 @@ function normalizeAnyOfFalseBranches(jsonSchema) {
         jsonSchema.anyOf = realBranches;
     }
 }
+/**
+ * Rejects nested schema resource identifiers that would change local reference scope.
+ *
+ * @throws {Error} If a nested subschema defines its own `$id`.
+ */
 function assertNoNestedSchemaIds(schema) {
     const visit = (value, path) => {
         if (typeof value === 'boolean' || !isObject(value)) {
@@ -1005,8 +1041,8 @@ function rewriteLocalRefsIntoFilteredAnyOfBranches(root) {
         let resolved = root;
         let changed = false;
         for (const [index, part] of originalParts.entries()) {
-            const resolvedRecord = typeof resolved === 'object' && resolved !== null && !Array.isArray(resolved) ?
-                resolved
+            const resolvedRecord = typeof resolved === 'object' && resolved !== null && !Array.isArray(resolved)
+                ? resolved
                 : undefined;
             if (part === 'anyOf' &&
                 index < originalParts.length - 1 &&
@@ -1018,7 +1054,7 @@ function rewriteLocalRefsIntoFilteredAnyOfBranches(root) {
                     return ref;
                 }
                 const branchIndex = Number(branchIndexPart);
-                if (!Object.prototype.hasOwnProperty.call(branches, branchIndex)) {
+                if (!(0, utils_1.hasOwn)(branches, branchIndex)) {
                     return ref;
                 }
                 const realBranches = branches.filter((branch) => branch !== false);
@@ -1097,7 +1133,7 @@ function preserveAllOfRefTargets(root, rootOnly = false) {
             throw new Error('Local $ref cannot be preserved before allOf flattening: ' + JSON.stringify(ref));
         }
         let alias = '__openai_strict_allOf_ref_' + aliasIndex++;
-        while (Object.prototype.hasOwnProperty.call(definitions, alias)) {
+        while ((0, utils_1.hasOwn)(definitions, alias)) {
             alias = '__openai_strict_allOf_ref_' + aliasIndex++;
         }
         definitions[alias] = structuredClone(target);
@@ -1158,7 +1194,7 @@ function preserveDiscardedAllOfPropertyRefTargets(root, discardedPaths) {
             throw new Error('Local $ref cannot be preserved before allOf property removal: ' + JSON.stringify(ref));
         }
         let alias = '__openai_strict_allOf_property_ref_' + aliasIndex++;
-        while (Object.prototype.hasOwnProperty.call(definitions, alias)) {
+        while ((0, utils_1.hasOwn)(definitions, alias)) {
             alias = '__openai_strict_allOf_property_ref_' + aliasIndex++;
         }
         definitions[alias] = structuredClone(target);
@@ -1309,7 +1345,7 @@ function normalizeObjectAllOfForExclusivity(schema, root) {
             for (const keyword of Object.keys(normalized)) {
                 delete normalized[keyword];
             }
-            Object.assign(normalized, flattened, siblings);
+            assignSchema(normalized, flattened, siblings);
         }
         return normalized;
     }
@@ -1422,8 +1458,9 @@ function mergeObjectAllOf(jsonSchema, path, root, normalizing = new Set()) {
     let hasExplicitNullableObjectType = false;
     const mergeAnnotations = (schema) => {
         for (const keyword of JSON_SCHEMA_ANNOTATION_KEYWORDS) {
-            if (!(keyword in schema))
+            if (!(keyword in schema)) {
                 continue;
+            }
             // Annotation keywords do not affect Draft 7 validation. Preserve the
             // first value (the outer schema, then earlier branches) instead of
             // rejecting an otherwise exactly mergeable intersection.
@@ -1434,16 +1471,18 @@ function mergeObjectAllOf(jsonSchema, path, root, normalizing = new Set()) {
     };
     mergeAnnotations(jsonSchema);
     for (const resolvedEntry of resolvedEntries) {
-        if (resolvedEntry === undefined)
+        if (resolvedEntry === undefined) {
             continue;
+        }
         for (const entry of resolvedEntry.refChain) {
             mergeAnnotations(entry);
         }
     }
     for (const { schema: branch, sourcePath } of branches) {
         for (const keyword of Object.keys(branch)) {
-            if (keyword === 'allOf' && branch === jsonSchema)
+            if (keyword === 'allOf' && branch === jsonSchema) {
                 continue;
+            }
             if ((keyword === '$defs' || keyword === 'definitions') &&
                 isObject(branch[keyword])) {
                 continue;
@@ -1484,8 +1523,9 @@ function mergeObjectAllOf(jsonSchema, path, root, normalizing = new Set()) {
                 fail();
             }
             sawRequired = true;
-            for (const key of branch.required)
+            for (const key of branch.required) {
                 mergedRequired.add(key);
+            }
         }
         if ('additionalProperties' in branch) {
             if (branch.additionalProperties !== false) {
@@ -1498,13 +1538,19 @@ function mergeObjectAllOf(jsonSchema, path, root, normalizing = new Set()) {
     // closed property sets before merging schemas so optional declarations
     // excluded by another closed branch are discarded, while required excluded
     // properties remain unrepresentable and fail closed.
-    const allowedClosedProperties = closedPropertySets.length === 0 ?
-        undefined
-        : closedPropertySets
-            .slice(1)
-            .reduce((allowed, keys) => new Set([...allowed].filter((key) => keys.has(key))), new Set(closedPropertySets[0]));
-    const excludesRequiredProperty = allowedClosedProperties !== undefined &&
-        [...mergedRequired].some((key) => !allowedClosedProperties.has(key));
+    let allowedClosedProperties;
+    if (closedPropertySets.length > 0) {
+        allowedClosedProperties = new Set(closedPropertySets[0]);
+        for (const keys of closedPropertySets.slice(1)) {
+            for (const key of allowedClosedProperties) {
+                if (!keys.has(key)) {
+                    allowedClosedProperties.delete(key);
+                }
+            }
+        }
+    }
+    const closedProperties = allowedClosedProperties;
+    const excludesRequiredProperty = closedProperties !== undefined && [...mergedRequired].some((key) => !closedProperties.has(key));
     const collapsesToNull = excludesRequiredProperty && !hasExplicitObjectType && hasExplicitNullableObjectType;
     const discardedPropertyPaths = propertyEntries
         .filter(({ key, sourcePath }) => sourcePath !== undefined &&
@@ -1523,7 +1569,7 @@ function mergeObjectAllOf(jsonSchema, path, root, normalizing = new Set()) {
             for (const keyword of Object.keys(jsonSchema)) {
                 delete jsonSchema[keyword];
             }
-            Object.assign(jsonSchema, merged);
+            assignSchema(jsonSchema, merged);
             return true;
         }
         fail();
@@ -1532,8 +1578,7 @@ function mergeObjectAllOf(jsonSchema, path, root, normalizing = new Set()) {
         if (allowedClosedProperties !== undefined && !allowedClosedProperties.has(key)) {
             continue;
         }
-        if (Object.prototype.hasOwnProperty.call(mergedProperties, key) &&
-            !schemasEqual(mergedProperties[key], propertySchema)) {
+        if ((0, utils_1.hasOwn)(mergedProperties, key) && !schemasEqual(mergedProperties[key], propertySchema)) {
             fail();
         }
         mergedProperties[key] = propertySchema;
@@ -1541,16 +1586,19 @@ function mergeObjectAllOf(jsonSchema, path, root, normalizing = new Set()) {
     if (hasExplicitObjectType || hasExplicitNullableObjectType) {
         merged.type = hasExplicitObjectType ? 'object' : ['object', 'null'];
     }
-    if (sawProperties)
+    if (sawProperties) {
         merged.properties = Object.fromEntries(Object.entries(mergedProperties));
-    if (sawRequired)
+    }
+    if (sawRequired) {
         merged.required = [...mergedRequired];
-    if (closedPropertySets.length > 0)
+    }
+    if (closedPropertySets.length > 0) {
         merged.additionalProperties = false;
+    }
     for (const keyword of Object.keys(jsonSchema)) {
         delete jsonSchema[keyword];
     }
-    Object.assign(jsonSchema, merged);
+    assignSchema(jsonSchema, merged);
     return true;
 }
 function hasObjectShapeWithoutAllOf(schema) {
@@ -1583,8 +1631,10 @@ function schemasEqual(left, right) {
     }
     const leftRecord = left;
     const rightRecord = right;
-    const leftKeys = Object.keys(leftRecord).sort();
-    const rightKeys = Object.keys(rightRecord).sort();
+    const leftKeys = Object.keys(leftRecord);
+    const rightKeys = Object.keys(rightRecord);
+    leftKeys.sort();
+    rightKeys.sort();
     if (leftKeys.length !== rightKeys.length) {
         return false;
     }