openai 7.4.0 → 7.6.0

package/src/internal/qs/utils.ts

@@ -2,10 +2,333 @@ import { RFC1738 } from './formats';
 import type { DefaultEncoder, Format } from './types';
 import { isArray } from '../utils/values';
 
-export let has = (obj: object, key: PropertyKey): boolean => (
-  (has = (Object as any).hasOwn ?? Function.prototype.call.bind(Object.prototype.hasOwnProperty)),
-  has(obj, key)
-);
+let cachedHas: ((obj: object, key: PropertyKey) => boolean) | undefined;
+
+export const has = (obj: object, key: PropertyKey): boolean => {
+  const resolvedHas: (obj: object, key: PropertyKey) => boolean =
+    cachedHas ?? (Object as any).hasOwn ?? Function.prototype.call.bind(Object.prototype.hasOwnProperty);
+  cachedHas = resolvedHas;
+  return resolvedHas(obj, key);
+};
+
+function isUnsafePropertyKey(key: unknown): boolean {
+  return key === '__proto__' || key === 'constructor' || key === 'prototype';
+}
+
+interface AdoptedRecord {
+  value: object;
+  descriptors: PropertyDescriptorMap;
+  keys: PropertyKey[];
+  prototype: object | null;
+  parents: Set<AdoptedRecord>;
+  ordinary: boolean;
+  array: boolean;
+  detached: boolean;
+  unsafe: boolean;
+  extensible: boolean;
+}
+
+interface MergeState {
+  adopted: { target: object; key: PropertyKey }[];
+  preparedTargets: WeakMap<object, Map<PropertyKey, any>>;
+  preparedSources: WeakMap<object, WeakMap<object, object>>;
+  inspectedSources: number;
+  inspectedSourceProperties: number;
+}
+
+const maxAdoptedRecords = 10_000;
+
+function isIntrinsicFunctionPrototype(
+  value: object,
+  key: PropertyKey,
+  descriptor: PropertyDescriptor,
+): boolean {
+  return (
+    typeof value === 'function' && key === 'prototype' && !descriptor.enumerable && !descriptor.configurable
+  );
+}
+
+function isObjectLike(value: unknown): value is object {
+  return value !== null && (typeof value === 'object' || typeof value === 'function');
+}
+
+function rememberAdoption(state: MergeState, target: object, key: PropertyKey, value: any): void {
+  if (!isObjectLike(value)) {
+    return;
+  }
+  if (state.adopted.length >= maxAdoptedRecords) {
+    throw new Error('Adopted record traversal exceeds the supported safety limit.');
+  }
+  state.adopted.push({ target, key });
+}
+
+function sanitizeAdoptions(state: MergeState): void {
+  if (state.adopted.length === 0) {
+    return;
+  }
+
+  const records = new WeakMap<object, AdoptedRecord>();
+  const visited: AdoptedRecord[] = [];
+  const locations: {
+    target: object;
+    key: PropertyKey;
+    descriptor: PropertyDescriptor;
+    record: AdoptedRecord;
+  }[] = [];
+  let inspectedProperties = 0;
+
+  function inspect(value: object): AdoptedRecord {
+    const known = records.get(value);
+    if (known) {
+      return known;
+    }
+    if (visited.length >= maxAdoptedRecords) {
+      throw new Error('Adopted record traversal exceeds the supported safety limit.');
+    }
+
+    const keys = Reflect.ownKeys(value);
+    if (keys.length > maxAdoptedRecords - inspectedProperties) {
+      throw new Error('Adopted record traversal exceeds the supported safety limit.');
+    }
+    inspectedProperties += keys.length;
+    const descriptors: PropertyDescriptorMap = Object.create(null);
+    for (const key of keys) {
+      const descriptor = Object.getOwnPropertyDescriptor(value, key);
+      if (descriptor) {
+        Reflect.set(descriptors, key, descriptor);
+      }
+    }
+    const prototype = Object.getPrototypeOf(value);
+    const array = isArray(value);
+    const extensible = Object.isExtensible(value);
+    const ordinary =
+      typeof value !== 'function' &&
+      (array ? prototype === Array.prototype : prototype === Object.prototype || prototype === null);
+    const record: AdoptedRecord = {
+      value,
+      descriptors,
+      keys,
+      prototype,
+      parents: new Set(),
+      ordinary,
+      array,
+      detached: ordinary && (extensible || !Object.isFrozen(value)),
+      unsafe: false,
+      extensible,
+    };
+    records.set(value, record);
+    visited.push(record);
+    return record;
+  }
+
+  for (const { target, key } of state.adopted) {
+    const descriptor = Object.getOwnPropertyDescriptor(target, key);
+    if (descriptor && 'value' in descriptor && isObjectLike(descriptor.value)) {
+      locations.push({ target, key, descriptor, record: inspect(descriptor.value) });
+    }
+  }
+
+  const detached: AdoptedRecord[] = [];
+  for (const record of visited) {
+    for (const key of record.keys) {
+      const descriptor = Reflect.get(record.descriptors, key) as PropertyDescriptor | undefined;
+      if (!descriptor) {
+        continue;
+      }
+      if (isUnsafePropertyKey(key)) {
+        if (record.ordinary) {
+          record.detached = true;
+          record.unsafe = true;
+        } else if (!isIntrinsicFunctionPrototype(record.value, key, descriptor)) {
+          throw new TypeError('Cannot safely sanitize an adopted callable or unsupported prototype.');
+        }
+        continue;
+      }
+      if (!record.ordinary && !descriptor.enumerable) {
+        continue;
+      }
+      if ('value' in descriptor && isObjectLike(descriptor.value)) {
+        inspect(descriptor.value).parents.add(record);
+      }
+    }
+    if (record.detached) {
+      detached.push(record);
+    }
+  }
+
+  for (let index = visited.length - 1; index >= 0; index -= 1) {
+    const record = visited[index]!;
+    if (record.ordinary) {
+      continue;
+    }
+    for (const key of ['__proto__', 'constructor', 'prototype'] as const) {
+      const descriptor = Object.getOwnPropertyDescriptor(record.value, key);
+      if (descriptor && !isIntrinsicFunctionPrototype(record.value, key, descriptor)) {
+        throw new TypeError('Cannot safely sanitize an adopted callable or unsupported prototype.');
+      }
+    }
+  }
+
+  const unsafe = visited.filter((record) => record.unsafe);
+  for (const record of unsafe) {
+    for (const parent of record.parents) {
+      if (!parent.ordinary) {
+        throw new TypeError('Cannot safely sanitize an adopted callable or unsupported prototype.');
+      }
+      if (!parent.unsafe) {
+        parent.unsafe = true;
+        unsafe.push(parent);
+      }
+    }
+  }
+
+  for (const record of detached) {
+    for (const parent of record.parents) {
+      if (!parent.ordinary) {
+        continue;
+      }
+      if (!parent.detached) {
+        parent.detached = true;
+        detached.push(parent);
+      }
+    }
+  }
+
+  const copies = new WeakMap<object, any>();
+  for (const record of detached) {
+    copies.set(record.value, record.array ? [] : Object.create(record.prototype));
+  }
+  for (const record of detached) {
+    const copy = copies.get(record.value);
+    for (const key of record.keys) {
+      if (isUnsafePropertyKey(key)) {
+        continue;
+      }
+      const descriptor = Reflect.get(record.descriptors, key) as PropertyDescriptor | undefined;
+      if (!descriptor) {
+        continue;
+      }
+      if ('value' in descriptor && isObjectLike(descriptor.value) && copies.has(descriptor.value)) {
+        descriptor.value = copies.get(descriptor.value);
+      }
+      Object.defineProperty(copy, key, descriptor);
+    }
+  }
+
+  for (const { target, key, descriptor, record } of locations) {
+    const value = copies.get(record.value) ?? record.value;
+    if (value !== descriptor.value) {
+      Object.defineProperty(copies.get(target) ?? target, key, { ...descriptor, value });
+    }
+  }
+
+  for (const record of detached) {
+    if (!record.extensible) {
+      Object.preventExtensions(copies.get(record.value));
+    }
+  }
+}
+
+function readPreparedTarget(state: MergeState, target: any, key: PropertyKey): any {
+  const prepared = state.preparedTargets.get(target);
+  if (prepared?.has(key)) {
+    const value = prepared.get(key);
+    prepared.delete(key);
+    return value;
+  }
+  return target[key];
+}
+
+function previewTarget(state: MergeState, target: object, key: PropertyKey): any {
+  const descriptor = Object.getOwnPropertyDescriptor(target, key);
+  if (descriptor && 'value' in descriptor) {
+    return descriptor.value;
+  }
+
+  const value = Reflect.get(target, key, target);
+  let prepared = state.preparedTargets.get(target);
+  if (!prepared) {
+    prepared = new Map();
+    state.preparedTargets.set(target, prepared);
+  }
+  prepared.set(key, value);
+  return value;
+}
+
+function prepareMergeSource(target: any, source: any, state: MergeState, assign = false): any {
+  if (!source || typeof source !== 'object' || !target || typeof target !== 'object') {
+    return source;
+  }
+
+  let preparedTargets = state.preparedSources.get(source);
+  if (!preparedTargets) {
+    preparedTargets = new WeakMap();
+    state.preparedSources.set(source, preparedTargets);
+  }
+  const existing = preparedTargets.get(target);
+  if (existing) {
+    return existing;
+  }
+  state.inspectedSources += 1;
+  if (state.inspectedSources > maxAdoptedRecords) {
+    throw new Error('Adopted record traversal exceeds the supported safety limit.');
+  }
+
+  const sourceKeys = Reflect.ownKeys(source);
+  if (sourceKeys.length > maxAdoptedRecords - state.inspectedSourceProperties) {
+    throw new Error('Adopted record traversal exceeds the supported safety limit.');
+  }
+  state.inspectedSourceProperties += sourceKeys.length;
+  const sourceIsArray = isArray(source);
+  const prepared: Record<string, any> = sourceIsArray ? [] : Object.create(null);
+  preparedTargets.set(target, prepared);
+
+  if (isArray(target) && sourceIsArray && !assign) {
+    const sourceLength = source.length;
+    (prepared as any[]).length = sourceLength;
+    for (let index = 0; index < sourceLength; index += 1) {
+      if (!(index in source)) {
+        continue;
+      }
+      const value = source[index];
+      if (has(target, index)) {
+        const targetValue = previewTarget(state, target, index);
+        prepared[index] =
+          targetValue && typeof targetValue === 'object' && value && typeof value === 'object'
+            ? prepareMergeSource(targetValue, value, state)
+            : value;
+      } else {
+        prepared[index] = value;
+      }
+    }
+    return prepared;
+  }
+
+  const enumerableKeys: string[] = [];
+  for (const key of sourceKeys) {
+    if (typeof key === 'string' && Object.getOwnPropertyDescriptor(source, key)?.enumerable) {
+      enumerableKeys.push(key);
+    }
+  }
+  for (const key of enumerableKeys) {
+    if (isUnsafePropertyKey(key)) {
+      continue;
+    }
+    const value = source[key];
+    prepared[key] =
+      !assign && has(target, key) && value && typeof value === 'object'
+        ? prepareMergeSource(previewTarget(state, target, key), value, state)
+        : value;
+  }
+  return prepared;
+}
+
+function prepareSource(target: any, source: any, state: MergeState, assign = false): any {
+  const holder = { value: prepareMergeSource(target, source, state, assign) };
+  rememberAdoption(state, holder, 'value', holder.value);
+  sanitizeAdoptions(state);
+  return holder.value;
+}
 
 const hex_table = /* @__PURE__ */ (() => {
   const array = [];
@@ -16,19 +339,21 @@ const hex_table = /* @__PURE__ */ (() => {
   return array;
 })();
 
-function compact_queue<T extends Record<string, any>>(queue: Array<{ obj: T; prop: string }>) {
+function compact_queue<T extends Record<string, any>>(queue: { obj: T; prop: string }[]) {
   while (queue.length > 1) {
     const item = queue.pop();
-    if (!item) continue;
+    if (!item) {
+      continue;
+    }
 
     const obj = item.obj[item.prop];
 
     if (isArray(obj)) {
       const compacted: unknown[] = [];
 
-      for (let j = 0; j < obj.length; ++j) {
-        if (typeof obj[j] !== 'undefined') {
-          compacted.push(obj[j]);
+      for (const value of obj) {
+        if (value !== undefined) {
+          compacted.push(value);
         }
       }
 
@@ -41,7 +366,7 @@ function compact_queue<T extends Record<string, any>>(queue: Array<{ obj: T; pro
 function array_to_object(source: any[], options: { plainObjects: boolean }) {
   const obj = options && options.plainObjects ? Object.create(null) : {};
   for (let i = 0; i < source.length; ++i) {
-    if (typeof source[i] !== 'undefined') {
+    if (source[i] !== undefined) {
       obj[i] = source[i];
     }
   }
@@ -49,11 +374,12 @@ function array_to_object(source: any[], options: { plainObjects: boolean }) {
   return obj;
 }
 
-export function merge(
+function mergeWithState(
   target: any,
   source: any,
-  options: { plainObjects?: boolean; allowPrototypes?: boolean } = {},
-) {
+  options: { plainObjects?: boolean; allowPrototypes?: boolean },
+  state: MergeState,
+): any {
   if (!source) {
     return target;
   }
@@ -62,8 +388,16 @@ export function merge(
     if (isArray(target)) {
       target.push(source);
     } else if (target && typeof target === 'object') {
-      if ((options && (options.plainObjects || options.allowPrototypes)) || !has(Object.prototype, source)) {
-        target[source] = true;
+      const propertyKey =
+        typeof source === 'string' || typeof source === 'symbol'
+          ? source
+          : Reflect.ownKeys({ [source]: true })[0]!;
+      if (
+        !isUnsafePropertyKey(propertyKey) &&
+        ((options && (options.plainObjects || options.allowPrototypes)) ||
+          !has(Object.prototype, propertyKey))
+      ) {
+        target[propertyKey] = true;
       }
     } else {
       return [target, source];
@@ -73,6 +407,7 @@ export function merge(
   }
 
   if (!target || typeof target !== 'object') {
+    // oxlint-disable-next-line unicorn/prefer-spread -- concat intentionally preserves one-level flattening and sparse-array behavior.
     return [target].concat(source);
   }
 
@@ -83,38 +418,72 @@ export function merge(
   }
 
   if (isArray(target) && isArray(source)) {
-    source.forEach(function (item, i) {
-      if (has(target, i)) {
-        const targetItem = target[i];
-        if (targetItem && typeof targetItem === 'object' && item && typeof item === 'object') {
-          target[i] = merge(targetItem, item, options);
+    const sourceLength = source.length;
+    for (let i = 0; i < sourceLength; i += 1) {
+      if (i in source) {
+        const item = source[i];
+        if (has(target, i)) {
+          const targetItem = readPreparedTarget(state, target, i);
+          if (targetItem && typeof targetItem === 'object' && item && typeof item === 'object') {
+            const merged = mergeWithState(targetItem, item, options, state);
+            target[i] = merged;
+          } else {
+            const adopted = item;
+            target.push(adopted);
+          }
         } else {
-          target.push(item);
+          const adopted = item;
+          target[i] = adopted;
         }
-      } else {
-        target[i] = item;
       }
-    });
+    }
     return target;
   }
 
-  return Object.keys(source).reduce(function (acc, key) {
+  for (const key of Object.keys(source)) {
+    if (isUnsafePropertyKey(key)) {
+      continue;
+    }
     const value = source[key];
+    const adopted = has(mergeTarget, key)
+      ? mergeWithState(readPreparedTarget(state, mergeTarget, key), value, options, state)
+      : value;
+    mergeTarget[key] = adopted;
+  }
+  return mergeTarget;
+}
 
-    if (has(acc, key)) {
-      acc[key] = merge(acc[key], value, options);
-    } else {
-      acc[key] = value;
-    }
-    return acc;
-  }, mergeTarget);
+export function merge(
+  target: any,
+  source: any,
+  options: { plainObjects?: boolean; allowPrototypes?: boolean } = {},
+) {
+  const state: MergeState = {
+    adopted: [],
+    preparedTargets: new WeakMap(),
+    preparedSources: new WeakMap(),
+    inspectedSources: 0,
+    inspectedSourceProperties: 0,
+  };
+  return mergeWithState(target, prepareSource(target, source, state), options, state);
 }
 
 export function assign_single_source(target: any, source: any) {
-  return Object.keys(source).reduce(function (acc, key) {
-    acc[key] = source[key];
-    return acc;
-  }, target);
+  const state: MergeState = {
+    adopted: [],
+    preparedTargets: new WeakMap(),
+    preparedSources: new WeakMap(),
+    inspectedSources: 0,
+    inspectedSourceProperties: 0,
+  };
+  const prepared = prepareSource(target, source, state, true);
+  for (const key of Object.keys(prepared)) {
+    if (isUnsafePropertyKey(key)) {
+      continue;
+    }
+    target[key] = prepared[key];
+  }
+  return target;
 }
 
 export function decode(str: string, _: any, charset: string) {
@@ -126,7 +495,7 @@ export function decode(str: string, _: any, charset: string) {
   // utf-8
   try {
     return decodeURIComponent(strWithoutPlus);
-  } catch (e) {
+  } catch {
     return strWithoutPlus;
   }
 }
@@ -154,17 +523,25 @@ export const encode: (
   }
 
   if (charset === 'iso-8859-1') {
-    return escape(string).replace(/%u[0-9a-f]{4}/gi, function ($0) {
-      return '%26%23' + parseInt($0.slice(2), 16) + '%3B';
-    });
+    return escape(string).replace(
+      /%u[0-9a-f]{4}/gi,
+      ($0) => '%26%23' + Number.parseInt($0.slice(2), 16) + '%3B',
+    );
   }
 
   let out = '';
-  for (let j = 0; j < string.length; j += limit) {
-    const segment = string.length >= limit ? string.slice(j, j + limit) : string;
+  for (let j = 0; j < string.length;) {
+    let segmentEnd = Math.min((Math.floor(j / limit) + 1) * limit, string.length);
+
+    if (segmentEnd < string.length && string.codePointAt(segmentEnd - 1)! > 0xff_ff) {
+      segmentEnd += 1;
+    }
+
+    const segment = string.length >= limit ? string.slice(j, segmentEnd) : string;
     const arr = [];
 
     for (let i = 0; i < segment.length; ++i) {
+      // oxlint-disable-next-line unicorn/prefer-code-point -- combine UTF-16 surrogate code units below
       let c = segment.charCodeAt(i);
       if (
         c === 0x2d || // -
@@ -185,19 +562,20 @@ export const encode: (
         continue;
       }
 
-      if (c < 0x800) {
+      if (c < 0x8_00) {
         arr[arr.length] = hex_table[0xc0 | (c >> 6)]! + hex_table[0x80 | (c & 0x3f)];
         continue;
       }
 
-      if (c < 0xd800 || c >= 0xe000) {
+      if (c < 0xd8_00 || c >= 0xe0_00) {
         arr[arr.length] =
           hex_table[0xe0 | (c >> 12)]! + hex_table[0x80 | ((c >> 6) & 0x3f)] + hex_table[0x80 | (c & 0x3f)];
         continue;
       }
 
       i += 1;
-      c = 0x10000 + (((c & 0x3ff) << 10) | (segment.charCodeAt(i) & 0x3ff));
+      // oxlint-disable-next-line unicorn/prefer-code-point -- combine UTF-16 surrogate code units manually
+      c = 0x1_00_00 + (((c & 0x3_ff) << 10) | (segment.charCodeAt(i) & 0x3_ff));
 
       arr[arr.length] =
         hex_table[0xf0 | (c >> 18)]! +
@@ -207,6 +585,7 @@ export const encode: (
     }
 
     out += arr.join('');
+    j = segmentEnd;
   }
 
   return out;
@@ -214,19 +593,17 @@ export const encode: (
 
 export function compact(value: any) {
   const queue = [{ obj: { o: value }, prop: 'o' }];
-  const refs = [];
+  const refs: object[] = [];
 
-  for (let i = 0; i < queue.length; ++i) {
-    const item = queue[i];
+  for (const item of queue) {
     // @ts-ignore
     const obj = item.obj[item.prop];
 
     const keys = Object.keys(obj);
-    for (let j = 0; j < keys.length; ++j) {
-      const key = keys[j]!;
+    for (const key of keys) {
       const val = obj[key];
-      if (typeof val === 'object' && val !== null && refs.indexOf(val) === -1) {
-        queue.push({ obj: obj, prop: key });
+      if (typeof val === 'object' && val !== null && !refs.includes(val)) {
+        queue.push({ obj, prop: key });
         refs.push(val);
       }
     }
@@ -250,14 +627,15 @@ export function is_buffer(obj: any) {
 }
 
 export function combine(a: any, b: any) {
+  // oxlint-disable-next-line unicorn/prefer-spread -- concat intentionally preserves one-level flattening and sparse-array behavior.
   return [].concat(a, b);
 }
 
 export function maybe_map<T>(val: T[], fn: (v: T) => T) {
   if (isArray(val)) {
     const mapped = [];
-    for (let i = 0; i < val.length; i += 1) {
-      mapped.push(fn(val[i]!));
+    for (const item of val) {
+      mapped.push(fn(item));
     }
     return mapped;
   }

package/src/internal/request-options.ts

@@ -1,5 +1,3 @@
-// File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
-
 import { NullableHeaders } from './headers';
 
 import type { BodyInit } from './builtin-types';
@@ -86,11 +84,62 @@ export type RequestOptions = {
 export type EncodedContent = { bodyHeaders: HeadersLike; body: BodyInit };
 export type RequestEncoder = (request: { headers: NullableHeaders; body: unknown }) => EncodedContent;
 
+interface JSONRequestBodyObserver {
+  value(holder: object, key: string, value: unknown): unknown;
+  complete(): void;
+}
+
+const jsonRequestBodyObservers = new WeakMap<object, Set<JSONRequestBodyObserver>>();
+
+/** Observes values produced by the actual JSON request serializer without changing them. */
+export function observeJSONRequestBody(body: object, observer: JSONRequestBodyObserver): () => void {
+  let observers = jsonRequestBodyObservers.get(body);
+  if (!observers) {
+    observers = new Set();
+    jsonRequestBodyObservers.set(body, observers);
+  }
+  observers.add(observer);
+
+  return () => {
+    const active = jsonRequestBodyObservers.get(body);
+    if (!active) {
+      return;
+    }
+    active.delete(observer);
+    if (active.size === 0) {
+      jsonRequestBodyObservers.delete(body);
+    }
+  };
+}
+
 export const FallbackEncoder: RequestEncoder = ({ headers, body }) => {
+  const observers =
+    typeof body === 'object' && body !== null ? jsonRequestBodyObservers.get(body) : undefined;
+  let encoded: string;
+
+  if (!observers || observers.size === 0) {
+    encoded = JSON.stringify(body);
+  } else {
+    const active = [...observers];
+    encoded = JSON.stringify(body, function (this: object, key: string, value: unknown): unknown {
+      let observed = value;
+      for (const observer of active) {
+        const replacement = observer.value(this, key, observed);
+        if (replacement !== undefined) {
+          observed = replacement;
+        }
+      }
+      return observed;
+    });
+    for (const observer of active) {
+      observer.complete();
+    }
+  }
+
   return {
     bodyHeaders: {
       'content-type': 'application/json',
     },
-    body: JSON.stringify(body),
+    body: encoded,
   };
 };