openai 7.4.0 → 7.6.0

package/src/internal/uploads.ts

@@ -1,4 +1,4 @@
-import { type RequestOptions } from './request-options';
+import type { RequestOptions } from './request-options';
 import type { FilePropertyBag, Fetch } from './builtin-types';
 import type { OpenAI } from '../client';
 import { buildHeaders } from './headers';
@@ -6,9 +6,21 @@ import { ReadableStreamFrom, ReadableStreamToAsyncIterable } from './shims';
 import type { ReadableStream } from './shim-types';
 import { encodeUTF8 } from './utils/bytes';
 
+/** Text, binary data, or a blob that can contribute bytes to an uploaded file. */
 export type BlobPart = string | ArrayBuffer | ArrayBufferView | Blob | DataView;
-type FsReadStream = AsyncIterable<Uint8Array> & { path: string | { toString(): string } };
 
+/** Node.js-compatible byte stream carrying the source path used to infer a filename. */
+type FsReadStream = AsyncIterable<Uint8Array> & {
+  /** Source filesystem path, represented as a string or path-like object. */
+  path:
+    | string
+    | {
+        /** Converts the path-like value into its filesystem path. */
+        toString(): string;
+      };
+};
+
+/** Asynchronous chunks consumed lazily while encoding a streaming multipart upload. */
 export type StreamingFileInput = AsyncIterable<BlobPart> | ReadableStream<BlobPart>;
 
 const brand_privateStreamingFile = /* @__PURE__ */ Symbol('brand.privateStreamingFile');
@@ -18,10 +30,19 @@ const brand_privateStreamingFile = /* @__PURE__ */ Symbol('brand.privateStreamin
  * Create one with {@link toStreamingFile} when buffering an upload into a `File` is undesirable.
  */
 export interface StreamingFile {
-  /** Brand check, prevent users from creating a StreamingFile without a filename. */
+  /** Ensures streaming files are created with a filename through {@link toStreamingFile}. */
   readonly [brand_privateStreamingFile]: true;
+
+  /** Source chunks read incrementally as the multipart request body is transmitted. */
   readonly data: StreamingFileInput;
+
+  /**
+   * Logical source filename; ordinary uploads send its basename, while Skills can preserve
+   * a validated relative directory path.
+   */
   readonly name: string;
+
+  /** Optional MIME type; defaults to `application/octet-stream` when omitted. */
   readonly type?: string | undefined;
 }
 
@@ -31,53 +52,79 @@ export interface StreamingFile {
  * Unlike {@link toFile}, this helper does not create a web `File`, because the `File` constructor
  * must consume all of its contents up front. The stream is instead encoded lazily as multipart
  * form data when the request is sent.
+ *
+ * @param data Async-iterable or readable-stream chunks containing text, binary data, or blobs.
+ * @param name Non-empty logical/source filename. Ordinary uploads send only its basename; Skills
+ * uploads may preserve a validated relative path with normalized forward slashes.
+ * @param options Optional MIME type for the streaming file.
+ * @throws {TypeError} If `name` is empty or the content type contains control characters.
  */
 export function toStreamingFile(
   data: StreamingFileInput,
   name: string,
   options?: Pick<FilePropertyBag, 'type'>,
 ): StreamingFile {
-  if (!name) {
+  if (typeof name !== 'string' || !name) {
     throw new TypeError('toStreamingFile requires a non-empty file name');
   }
 
+  const type = options?.type;
+  if (type) {
+    validateStreamingFileType(type);
+  }
+
   return {
     [brand_privateStreamingFile]: true,
     data,
     name,
-    ...(options?.type ? { type: options.type } : {}),
+    ...(type ? { type } : {}),
   };
 }
 
-// https://github.com/oven-sh/bun/issues/5980
+/**
+ * Bun file compatibility shape for file objects whose names are optional in their types.
+ *
+ * @see https://github.com/oven-sh/bun/issues/5980
+ */
 interface BunFile extends Blob {
+  /** Filename exposed by Bun when one is available. */
   readonly name?: string | undefined;
 }
 
-type NamedBlob = Blob & { readonly name?: string | undefined };
+/** Blob-compatible upload value that exposes a filename at runtime. */
+type NamedBlob = Blob & {
+  /** Filename supplied by a native `File` or another named Blob implementation. */
+  readonly name?: string | undefined;
+};
 
+/**
+ * Verifies that the current runtime exposes the global `File` constructor.
+ *
+ * @throws {Error} If `File` is unavailable; older Node.js runtimes receive an
+ * additional upgrade or `node:buffer` compatibility suggestion.
+ */
 export const checkFileSupport = () => {
   if (typeof File === 'undefined') {
     const { process } = globalThis as any;
     const isOldNode =
-      typeof process?.versions?.node === 'string' && parseInt(process.versions.node.split('.')) < 20;
+      typeof process?.versions?.node === 'string' &&
+      Number.parseInt(process.versions.node.split('.'), 10) < 20;
     throw new Error(
       '`File` is not defined as a global, which is required for file uploads.' +
-        (isOldNode ?
-          " Update to a supported Node.js LTS release, or set `globalThis.File` to `import('node:buffer').File`."
-        : ''),
+        (isOldNode
+          ? " Update to a supported Node.js LTS release, or set `globalThis.File` to `import('node:buffer').File`."
+          : ''),
     );
   }
 };
 
 /**
- * Typically, this is a native "File" class.
- *
- * We provide the {@link toFile} utility to convert a variety of objects
- * into the File class.
+ * Values accepted by SDK methods that upload multipart files.
  *
- * For convenience, you can also pass a fetch Response, or in Node,
- * the result of fs.createReadStream().
+ * Supports native files, fetch responses, blobs, Node.js filesystem read
+ * streams, async byte sources, web readable streams, and files created with
+ * {@link toStreamingFile}. Use {@link toFile} to materialize compatible content
+ * as a native `File` when buffering the complete upload is acceptable.
  */
 export type Uploadable =
   | File
@@ -92,6 +139,8 @@ export type Uploadable =
 /**
  * Construct a `File` instance. This is used to ensure a helpful error is thrown
  * for environments that don't define a global `File` yet.
+ *
+ * A missing filename becomes `unknown_file`.
  */
 export function makeFile(
   fileBits: BlobPart[],
@@ -102,53 +151,101 @@ export function makeFile(
   return new File(fileBits as any, fileName ?? 'unknown_file', options);
 }
 
-export function getName(value: any): string | undefined {
-  return (
-    (
-      (typeof value === 'object' &&
-        value !== null &&
-        (('name' in value && value.name && String(value.name)) ||
-          ('url' in value && value.url && String(value.url)) ||
-          ('filename' in value && value.filename && String(value.filename)) ||
-          ('path' in value && value.path && String(value.path)))) ||
-      ''
-    )
-      .split(/[\\/]/)
-      .pop() || undefined
-  );
+/**
+ * Infers a filename from an object's `name`, `url`, `filename`, or `path` value.
+ *
+ * Directory components separated by either `/` or `\\` are discarded unless an
+ * explicitly supplied `name` or `filename` opts into preserving its path. Preserved
+ * paths must be safe and relative, and use forward slashes. Paths inferred from URLs and filesystem streams
+ * discard their directories.
+ */
+export function getName(value: any, options?: { stripFilename?: boolean | undefined }): string | undefined {
+  if (typeof value !== 'object' || value === null) {
+    return undefined;
+  }
+
+  const name = 'name' in value ? value.name : undefined;
+  const explicitName =
+    (name && String(name)) || ('filename' in value && value.filename && String(value.filename));
+  if (explicitName) {
+    return options?.stripFilename === false ? normalizeFilenamePath(explicitName) : basename(explicitName);
+  }
+
+  const url = 'url' in value && value.url && String(value.url);
+  if (url) {
+    try {
+      return basename(new URL(url).pathname);
+    } catch {
+      return basename(url);
+    }
+  }
+
+  const path = 'path' in value && value.path && String(value.path);
+  return path ? basename(path) : undefined;
+}
+
+function basename(value: string): string | undefined {
+  return value.split(/[\\/]/).pop() || undefined;
+}
+
+function normalizeFilenamePath(value: string): string {
+  const normalized = value.replace(/\\/g, '/');
+  if (normalized.startsWith('/') || /^[A-Za-z]:/.test(normalized) || normalized.split('/').includes('..')) {
+    throw new TypeError('Upload file name must be a safe relative path without parent directory segments');
+  }
+  return normalized;
 }
 
+/** Identifies objects that expose a callable `Symbol.asyncIterator` method. */
 export const isAsyncIterable = (value: any): value is AsyncIterable<any> =>
   value != null && typeof value === 'object' && typeof value[Symbol.asyncIterator] === 'function';
 
 /**
- * Returns a multipart/form-data request if any part of the given request body contains a File / Blob value.
- * Otherwise returns the request as is.
+ * Converts a request to multipart form data when its body contains an upload.
+ *
+ * Uploads include files, blobs, responses, async iterables, readable
+ * streams, and {@link StreamingFile} values anywhere in a nested body. Bodies
+ * containing streaming values are encoded lazily; other uploads use `FormData`.
+ * Requests without uploads are returned unchanged.
  */
 export const maybeMultipartFormRequestOptions = async (
   opts: RequestOptions,
   fetch: OpenAI | Fetch,
+  formOptions?: CreateFormOptions,
 ): Promise<RequestOptions> => {
-  if (!hasUploadableValue(opts.body)) return opts;
+  if (!hasUploadableValue(opts.body)) {
+    return opts;
+  }
 
   if (hasStreamingUploadableValue(opts.body)) {
-    return createStreamingFormRequestOptions(opts);
+    return createStreamingFormRequestOptions(opts, formOptions);
   }
 
-  return { ...opts, body: await createForm(opts.body, fetch) };
+  return { ...opts, body: await createForm(opts.body, fetch, formOptions) };
 };
 
-type MultipartFormRequestOptions = Omit<RequestOptions, 'body'> & { body: unknown };
+/** Request options whose body must be encoded as multipart form data. */
+type MultipartFormRequestOptions = Omit<RequestOptions, 'body'> & {
+  /** Nested fields and upload values to encode into the multipart request body. */
+  body: unknown;
+};
 
+/**
+ * Encodes a request body as multipart form data even when no file is present.
+ *
+ * Streaming uploads produce a lazy multipart `ReadableStream` and an explicit
+ * boundary header; other values are materialized into platform `FormData`.
+ */
 export const multipartFormRequestOptions = async (
   opts: MultipartFormRequestOptions,
   fetch: OpenAI | Fetch,
+  formOptions?: CreateFormOptions,
 ): Promise<RequestOptions> => {
   if (hasStreamingUploadableValue(opts.body)) {
-    return createStreamingFormRequestOptions(opts);
+    return createStreamingFormRequestOptions(opts, formOptions);
   }
 
-  return { ...opts, body: await createForm(opts.body, fetch) };
+  return { ...opts, body: await createForm(opts.body, fetch, formOptions) };
 };
 
 const supportsFormDataMap = /* @__PURE__ */ new WeakMap<Fetch, Promise<boolean>>();
@@ -162,7 +259,9 @@ const supportsFormDataMap = /* @__PURE__ */ new WeakMap<Fetch, Promise<boolean>>
 function supportsFormData(fetchObject: OpenAI | Fetch): Promise<boolean> {
   const fetch: Fetch = typeof fetchObject === 'function' ? fetchObject : (fetchObject as any).fetch;
   const cached = supportsFormDataMap.get(fetch);
-  if (cached) return cached;
+  if (cached) {
+    return cached;
+  }
   const promise = (async () => {
     try {
       let FetchResponse: typeof Response;
@@ -187,9 +286,26 @@ function supportsFormData(fetchObject: OpenAI | Fetch): Promise<boolean> {
   return promise;
 }
 
+/** Controls whether explicitly supplied multipart filenames retain directory components. */
+export type CreateFormOptions = {
+  /** Keep directories in explicit filenames when false; inferred paths remain basename-only. */
+  stripFilenames?: boolean;
+};
+
+/**
+ * Materializes an object into platform `FormData` after verifying fetch support.
+ *
+ * Strings, numbers, and booleans become text fields; responses, blobs,
+ * and async byte sources become file fields. Arrays and nested objects use
+ * bracketed field names, while `undefined` values are omitted.
+ *
+ * @throws {TypeError} If the fetch implementation cannot encode global
+ * `FormData`, a field is `null`, or a field has an unsupported value.
+ */
 export const createForm = async <T = Record<string, unknown>>(
   body: T | undefined,
   fetch: OpenAI | Fetch,
+  options: CreateFormOptions = {},
 ): Promise<FormData> => {
   if (!(await supportsFormData(fetch))) {
     throw new TypeError(
@@ -197,13 +313,14 @@ export const createForm = async <T = Record<string, unknown>>(
     );
   }
   const form = new FormData();
-  await Promise.all(Object.entries(body || {}).map(([key, value]) => addFormValue(form, key, value)));
+  await Promise.all(
+    Object.entries(body || {}).map(([key, value]) => addFormValue(form, key, value, options)),
+  );
   return form;
 };
 
-// We check for Blob not File because Bun.File doesn't inherit from File,
-// but they both inherit from Blob and have a `name` property at runtime.
-const isNamedBlob = (value: unknown): value is NamedBlob => value instanceof Blob && 'name' in value;
+// Native files, Bun files, and unnamed upload values all inherit from Blob.
+const isBlob = (value: unknown): value is Blob => value instanceof Blob;
 
 const isReadableStream = (value: unknown): value is ReadableStream<BlobPart> =>
   typeof value === 'object' &&
@@ -214,32 +331,44 @@ const isReadableStream = (value: unknown): value is ReadableStream<BlobPart> =>
 const isStreamingFile = (value: unknown): value is StreamingFile =>
   typeof value === 'object' && value !== null && brand_privateStreamingFile in value;
 
-const isUploadable = (value: unknown) =>
+const isUploadable = (value: unknown): value is Uploadable =>
   typeof value === 'object' &&
   value !== null &&
   (value instanceof Response ||
     isAsyncIterable(value) ||
     isReadableStream(value) ||
     isStreamingFile(value) ||
-    isNamedBlob(value));
+    isBlob(value));
 
 const hasStreamingUploadableValue = (value: unknown): boolean => {
-  if (isStreamingFile(value) || isAsyncIterable(value) || isReadableStream(value)) return true;
-  if (Array.isArray(value)) return value.some(hasStreamingUploadableValue);
-  if (value && typeof value === 'object' && !isNamedBlob(value) && !(value instanceof Response)) {
+  if (isStreamingFile(value) || isAsyncIterable(value) || isReadableStream(value)) {
+    return true;
+  }
+  if (Array.isArray(value)) {
+    return value.some(hasStreamingUploadableValue);
+  }
+  if (value && typeof value === 'object' && !isBlob(value) && !(value instanceof Response)) {
     for (const k in value) {
-      if (hasStreamingUploadableValue((value as Record<string, unknown>)[k])) return true;
+      if (hasStreamingUploadableValue((value as Record<string, unknown>)[k])) {
+        return true;
+      }
     }
   }
   return false;
 };
 
 const hasUploadableValue = (value: unknown): boolean => {
-  if (isUploadable(value)) return true;
-  if (Array.isArray(value)) return value.some(hasUploadableValue);
+  if (isUploadable(value)) {
+    return true;
+  }
+  if (Array.isArray(value)) {
+    return value.some(hasUploadableValue);
+  }
   if (value && typeof value === 'object') {
     for (const k in value) {
-      if (hasUploadableValue((value as any)[k])) return true;
+      if (hasUploadableValue((value as any)[k])) {
+        return true;
+      }
     }
   }
   return false;
@@ -247,9 +376,34 @@ const hasUploadableValue = (value: unknown): boolean => {
 
 type FormEntry = { key: string; value: unknown };
 
-const createStreamingFormRequestOptions = (opts: RequestOptions): RequestOptions => {
+const snapshotPreservedUploadEntries = (
+  entries: Iterable<FormEntry>,
+  filenames: WeakMap<object, string>,
+): FormEntry[] => {
+  const snapshot: FormEntry[] = [];
+  for (const entry of entries) {
+    if (isUploadable(entry.value) && !filenames.has(entry.value)) {
+      filenames.set(entry.value, getStreamingFileName(entry.value, { stripFilenames: false }));
+    }
+    snapshot.push(entry);
+  }
+  return snapshot;
+};
+
+const createStreamingFormRequestOptions = (
+  opts: RequestOptions,
+  options: CreateFormOptions = {},
+): RequestOptions => {
+  const entries = iterateFormEntries(opts.body);
+  const preservedFilenames = options.stripFilenames === false ? new WeakMap<object, string>() : undefined;
+  const multipartEntries = preservedFilenames
+    ? snapshotPreservedUploadEntries(entries, preservedFilenames)
+    : entries;
+
   const boundary = `openai-${Math.random().toString(36).slice(2)}`;
-  const body = ReadableStreamFrom(iterateMultipartBody(opts.body, boundary));
+  const body = ReadableStreamFrom(
+    iterateMultipartBody(multipartEntries, boundary, options, preservedFilenames),
+  );
 
   return {
     ...opts,
@@ -258,19 +412,25 @@ const createStreamingFormRequestOptions = (opts: RequestOptions): RequestOptions
   };
 };
 
-async function* iterateMultipartBody(body: unknown, boundary: string): AsyncGenerator<Uint8Array> {
-  for await (const { key, value } of iterateFormEntries(body)) {
-    yield encodeUTF8(`--${boundary}\r\n`);
+async function* iterateMultipartBody(
+  entries: Iterable<FormEntry>,
+  boundary: string,
+  options: CreateFormOptions,
+  preservedFilenames?: WeakMap<object, string>,
+): AsyncGenerator<Uint8Array> {
+  for await (const { key, value } of entries) {
     if (isUploadable(value)) {
-      const filename = getStreamingFileName(value);
+      const filename = preservedFilenames?.get(value) ?? getStreamingFileName(value, options);
       const type = getStreamingFileType(value);
+      yield encodeUTF8(`--${boundary}\r\n`);
       yield encodeUTF8(
         `Content-Disposition: form-data; name="${escapeHeaderValue(key)}"; filename="${escapeHeaderValue(
           filename,
-        )}"\r\n` + `Content-Type: ${type}\r\n\r\n`,
+        )}"\r\nContent-Type: ${type}\r\n\r\n`,
       );
       yield* iterateBytes(getStreamingFileData(value));
     } else {
+      yield encodeUTF8(`--${boundary}\r\n`);
       yield encodeUTF8(
         `Content-Disposition: form-data; name="${escapeHeaderValue(key)}"\r\n\r\n${String(value)}`,
       );
@@ -280,16 +440,20 @@ async function* iterateMultipartBody(body: unknown, boundary: string): AsyncGene
   yield encodeUTF8(`--${boundary}--\r\n`);
 }
 
-async function* iterateFormEntries(body: unknown): AsyncGenerator<FormEntry> {
-  if (!body || typeof body !== 'object') return;
+function* iterateFormEntries(body: unknown): Generator<FormEntry> {
+  if (!body || typeof body !== 'object') {
+    return;
+  }
 
   for (const [key, value] of Object.entries(body)) {
     yield* iterateFormValue(key, value);
   }
 }
 
-async function* iterateFormValue(key: string, value: unknown): AsyncGenerator<FormEntry> {
-  if (value === undefined) return;
+function* iterateFormValue(key: string, value: unknown): Generator<FormEntry> {
+  if (value === undefined) {
+    return;
+  }
   if (value == null) {
     throw new TypeError(
       `Received null for "${key}"; to pass null in FormData, you must use the string 'null'`,
@@ -318,19 +482,52 @@ async function* iterateFormValue(key: string, value: unknown): AsyncGenerator<Fo
   }
 }
 
-function getStreamingFileName(value: Uploadable): string {
-  return isStreamingFile(value) ? value.name : getName(value) ?? 'unknown_file';
+function getStreamingFileName(value: Uploadable, options: CreateFormOptions): string {
+  if (isStreamingFile(value)) {
+    const { name } = value;
+    if (typeof name !== 'string' || !name) {
+      throw new TypeError('Streaming upload file name must be a non-empty string');
+    }
+
+    return options.stripFilenames === false
+      ? normalizeFilenamePath(name)
+      : (basename(name) ?? 'unknown_file');
+  }
+
+  return getName(value, { stripFilename: options.stripFilenames }) ?? 'unknown_file';
 }
 
 function getStreamingFileType(value: Uploadable): string {
-  if (isStreamingFile(value)) return value.type || 'application/octet-stream';
-  if (isNamedBlob(value) && value.type) return value.type;
-  if (value instanceof Response) return value.headers.get('content-type') || 'application/octet-stream';
-  return 'application/octet-stream';
+  let type: string | undefined;
+
+  if (isStreamingFile(value) || isBlob(value)) {
+    ({ type } = value);
+  } else if (value instanceof Response) {
+    type = value.headers.get('content-type') ?? undefined;
+  }
+
+  return validateStreamingFileType(type || 'application/octet-stream');
+}
+
+function validateStreamingFileType(type: string): string {
+  if (typeof type !== 'string') {
+    throw new TypeError('Streaming upload content type must be a string');
+  }
+
+  for (let index = 0; index < type.length; index += 1) {
+    const character = type.codePointAt(index) ?? 0;
+    if (character <= 0x1f || character === 0x7f) {
+      throw new TypeError('Streaming upload content type must not contain control characters');
+    }
+  }
+
+  return type;
 }
 
 function getStreamingFileData(value: Uploadable): unknown {
-  if (isStreamingFile(value)) return value.data;
+  if (isStreamingFile(value)) {
+    return value.data;
+  }
   return value;
 }
 
@@ -342,11 +539,7 @@ async function* iterateBytes(value: unknown): AsyncGenerator<Uint8Array> {
   } else if (value instanceof ArrayBuffer) {
     yield new Uint8Array(value);
   } else if (value instanceof Response) {
-    if (value.body) {
-      yield* iterateBytes(value.body);
-    } else {
-      yield* iterateBytes(await value.blob());
-    }
+    yield* iterateBytes(value.body || (await value.blob()));
   } else if (value instanceof Blob) {
     if (typeof value.stream === 'function') {
       yield* iterateBytes(value.stream());
@@ -367,31 +560,75 @@ async function* iterateBytes(value: unknown): AsyncGenerator<Uint8Array> {
 }
 
 function escapeHeaderValue(value: string): string {
-  return value.replace(/["\\\r\n]/g, (character) => encodeURIComponent(character));
+  return Array.from(value, (character) => {
+    const codePoint = character.codePointAt(0) ?? 0;
+    return codePoint <= 0x1f || codePoint === 0x7f || character === '"' || character === '\\'
+      ? encodeURIComponent(character)
+      : character;
+  }).join('');
 }
 
-const addFormValue = async (form: FormData, key: string, value: unknown): Promise<void> => {
-  if (value === undefined) return;
+const addFormValue = async (
+  form: FormData,
+  key: string,
+  value: unknown,
+  options: CreateFormOptions,
+): Promise<void> => {
+  if (value === undefined) {
+    return;
+  }
   if (value == null) {
     throw new TypeError(
       `Received null for "${key}"; to pass null in FormData, you must use the string 'null'`,
     );
   }
 
-  // TODO: make nested formats configurable
+  // Nested form keys use the current bracketed encoding.
   if (typeof value === 'string' || typeof value === 'number' || typeof value === 'boolean') {
     form.append(key, String(value));
   } else if (value instanceof Response) {
-    form.append(key, makeFile([await value.blob()], getName(value)));
+    const blob = await value.blob();
+    form.append(
+      key,
+      makeFile([blob], getName(value, { stripFilename: options.stripFilenames }), { type: blob.type }),
+    );
   } else if (isAsyncIterable(value)) {
-    form.append(key, makeFile([await new Response(ReadableStreamFrom(value)).blob()], getName(value)));
-  } else if (isNamedBlob(value)) {
-    form.append(key, value, getName(value));
+    form.append(
+      key,
+      makeFile(
+        [await new Response(ReadableStreamFrom(value)).blob()],
+        getName(value, { stripFilename: options.stripFilenames }),
+      ),
+    );
+  } else if (isBlob(value)) {
+    const filename = getName(value, { stripFilename: options.stripFilenames });
+    if (filename === undefined) {
+      form.append(key, value);
+    } else {
+      form.append(key, value, filename);
+    }
   } else if (Array.isArray(value)) {
-    await Promise.all(value.map((entry) => addFormValue(form, key + '[]', entry)));
+    // Prepare array elements concurrently, then preserve their repeated-field order.
+    const entries = await Promise.all(
+      value.map(async (entry) => {
+        const entryForm = new FormData();
+        await addFormValue(entryForm, key + '[]', entry, options);
+        return entryForm;
+      }),
+    );
+
+    for (const entryForm of entries) {
+      if (!entryForm) {
+        continue;
+      }
+
+      for (const [entryKey, entryValue] of entryForm.entries()) {
+        form.append(entryKey, entryValue);
+      }
+    }
   } else if (typeof value === 'object') {
     await Promise.all(
-      Object.entries(value).map(([name, prop]) => addFormValue(form, `${key}[${name}]`, prop)),
+      Object.entries(value).map(([name, prop]) => addFormValue(form, `${key}[${name}]`, prop, options)),
     );
   } else {
     throw new TypeError(

package/src/internal/utils/base64.ts

@@ -1,5 +1,3 @@
-// File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
-
 import { OpenAIError } from '../../core/error';
 import { encodeUTF8 } from './bytes';
 

package/src/internal/utils/bytes.ts

@@ -1,3 +1,4 @@
+/** Copies byte arrays into one contiguous `Uint8Array` while preserving their order. */
 export function concatBytes(buffers: Uint8Array[]): Uint8Array {
   let length = 0;
   for (const buffer of buffers) {
@@ -14,6 +15,8 @@ export function concatBytes(buffers: Uint8Array[]): Uint8Array {
 }
 
 let encodeUTF8_: (str: string) => Uint8Array;
+
+/** Encodes text as UTF-8 bytes, reusing the platform encoder after its first call. */
 export function encodeUTF8(str: string) {
   let encoder;
   return (
@@ -23,6 +26,8 @@ export function encodeUTF8(str: string) {
 }
 
 let decodeUTF8_: (bytes: Uint8Array) => string;
+
+/** Decodes UTF-8 bytes as text, reusing the platform decoder after its first call. */
 export function decodeUTF8(bytes: Uint8Array) {
   let decoder;
   return (