openai 4.0.0-beta.0 → 4.0.0-beta.1

package/README.md

@@ -24,12 +24,12 @@ yarn add openai
 ```js
 import OpenAI from 'openai';
 
-const openAI = new OpenAI({
+const openai = new OpenAI({
   apiKey: 'my api key', // defaults to process.env["OPENAI_API_KEY"]
 });
 
 async function main() {
-  const completion = await openAI.completions.create({
+  const completion = await openai.completions.create({
     model: 'text-davinci-002',
     prompt: 'Say this is a test',
     max_tokens: 6,
@@ -71,7 +71,7 @@ If you like, you may reference our types directly:
 ```ts
 import OpenAI from 'openai';
 
-const openAI = new OpenAI({
+const openai = new OpenAI({
   apiKey: 'my api key', // defaults to process.env["OPENAI_API_KEY"]
 });
 
@@ -82,7 +82,7 @@ async function main() {
     max_tokens: 6,
     temperature: 0,
   };
-  const completion: OpenAI.Completion = await openAI.completions.create(params);
+  const completion: OpenAI.Completion = await openai.completions.create(params);
 }
 main().catch(console.error);
 ```
@@ -91,17 +91,38 @@ Documentation for each method, request param, and response field are available i
 
 ## File Uploads
 
-Request parameters that correspond to file uploads can be passed as either a `FormData.Blob` or a `FormData.File` instance.
+Request parameters that correspond to file uploads can be passed in many different forms:
 
-We provide a `fileFromPath` helper function to easily create `FormData.File` instances from a given class.
+- `File` (or an object with the same structure)
+- a `fetch` `Response` (or an object with the same structure)
+- an `fs.ReadStream`
+- the return value of our `toFile` helper
 
 ```ts
-import OpenAI, { fileFromPath } from 'openai';
+import fs from 'fs';
+import fetch from 'node-fetch';
+import OpenAI, { toFile } from 'openai';
 
-const openAI = new OpenAI();
+const openai = new OpenAI();
 
-const file = await fileFromPath('input.jsonl');
-await openAI.files.create({ file: file, purpose: 'fine-tune' });
+// If you have access to Node `fs` we recommend using `fs.createReadStream()`:
+await openai.files.create({ file: fs.createReadStream('input.jsonl'), purpose: 'fine-tune' });
+
+// Or if you have the web `File` API you can pass a `File` instance:
+await openai.files.create({ file: new File(['my bytes'], 'input.jsonl'), purpose: 'fine-tune' });
+
+// You can also pass a `fetch` `Response`:
+await openai.files.create({ file: await fetch('https://somesite/input.jsonl'), purpose: 'fine-tune' });
+
+// Finally, if none of the above are convenient, you can use our `toFile` helper:
+await openai.files.create({
+  file: await toFile(Buffer.from('my bytes'), 'input.jsonl'),
+  purpose: 'fine-tune',
+});
+await openai.files.create({
+  file: await toFile(new Uint8Array([0, 1, 2]), 'input.jsonl'),
+  purpose: 'fine-tune',
+});
 ```
 
 ## Handling errors
@@ -112,7 +133,7 @@ a subclass of `APIError` will be thrown:
 
 ```ts
 async function main() {
-  const fineTune = await openAI.fineTunes
+  const fineTune = await openai.fineTunes
     .create({ training_file: 'file-XGinujblHPwGLSztz8cPS8XY' })
     .catch((err) => {
       if (err instanceof OpenAI.APIError) {
@@ -150,12 +171,12 @@ You can use the `maxRetries` option to configure or disable this:
 <!-- prettier-ignore -->
 ```js
 // Configure the default for all requests:
-const openAI = new OpenAI({
+const openai = new OpenAI({
   maxRetries: 0, // default is 2
 });
 
 // Or, configure per-request:
-openAI.embeddings.create({ model: 'text-similarity-babbage-001',input: 'The food was delicious and the waiter...' }, {
+openai.embeddings.create({ model: 'text-similarity-babbage-001',input: 'The food was delicious and the waiter...' }, {
   maxRetries: 5,
 });
 ```
@@ -167,12 +188,12 @@ Requests time out after 60 seconds by default. You can configure this with a `ti
 <!-- prettier-ignore -->
 ```ts
 // Configure the default for all requests:
-const openAI = new OpenAI({
+const openai = new OpenAI({
   timeout: 20 * 1000, // 20 seconds (default is 60s)
 });
 
 // Override per-request:
-openAI.edits.create({ model: 'text-davinci-edit-001',input: 'What day of the wek is it?',instruction: 'Fix the spelling mistakes' }, {
+openai.edits.create({ model: 'text-davinci-edit-001',input: 'What day of the wek is it?',instruction: 'Fix the spelling mistakes' }, {
   timeout: 5 * 1000,
 });
 ```
@@ -193,12 +214,12 @@ import http from 'http';
 import HttpsProxyAgent from 'https-proxy-agent';
 
 // Configure the default for all requests:
-const openAI = new OpenAI({
+const openai = new OpenAI({
   httpAgent: new HttpsProxyAgent(process.env.PROXY_URL),
 });
 
 // Override per-request:
-openAI.models.list({
+openai.models.list({
   baseURL: 'http://localhost:8080/test-api',
   httpAgent: new http.Agent({ keepAlive: false }),
 })
@@ -216,7 +237,7 @@ We are keen for your feedback; please open an [issue](https://www.github.com/ope
 
 The following runtimes are supported:
 
-- Node.js version 12 or higher.
+- Node.js 16 LTS or later ([non-EOL](https://endoflife.date/nodejs)) versions.
 - Deno v1.28.0 or higher (experimental).
   Use `import OpenAI from "npm:openai"`.
 

package/_shims/agent.node.ts

@@ -0,0 +1,20 @@
+/**
+ * Disclaimer: modules in _shims aren't intended to be imported by SDK users.
+ */
+
+import KeepAliveAgent from 'agentkeepalive';
+import type { Agent } from 'node:http';
+import { AbortController as AbortControllerPolyfill } from 'abort-controller';
+
+const defaultHttpAgent: Agent = new KeepAliveAgent({ keepAlive: true, timeout: 5 * 60 * 1000 });
+const defaultHttpsAgent: Agent = new KeepAliveAgent.HttpsAgent({ keepAlive: true, timeout: 5 * 60 * 1000 });
+
+// Polyfill global object if needed.
+if (typeof AbortController === 'undefined') {
+  AbortController = AbortControllerPolyfill as any as typeof AbortController;
+}
+
+export const getDefaultAgent = (url: string): Agent | undefined => {
+  if (defaultHttpsAgent && url.startsWith('https')) return defaultHttpsAgent;
+  return defaultHttpAgent;
+};

package/_shims/agent.ts

@@ -0,0 +1,12 @@
+/**
+ * Disclaimer: modules in _shims aren't intended to be imported by SDK users.
+ *
+ * This is a stub for non-node environments.
+ * In node environments, it gets replaced agent.node.ts by the package export map
+ */
+
+import type { Agent } from 'node:http';
+
+export const getDefaultAgent = (url: string): Agent | undefined => {
+  return undefined;
+};

package/_shims/fetch.node.ts

@@ -0,0 +1,11 @@
+/**
+ * Disclaimer: modules in _shims aren't intended to be imported by SDK users.
+ */
+
+import fetch, { Request, Response, Headers } from 'node-fetch';
+import type { RequestInfo, RequestInit, BodyInit } from 'node-fetch';
+
+export { fetch, Request, Response, Headers };
+export type { RequestInfo, RequestInit, BodyInit };
+
+export const isPolyfilled = true;

package/_shims/fetch.ts

@@ -0,0 +1,32 @@
+/**
+ * Disclaimer: modules in _shims aren't intended to be imported by SDK users.
+ */
+
+import type * as nf from 'node-fetch';
+
+const _fetch: typeof nf.default =
+  // @ts-ignore
+  fetch as any;
+type _fetch = typeof nf.default;
+const _Request: typeof nf.Request =
+  // @ts-ignore
+  Request as any;
+type _Request = nf.Request;
+const _Response: typeof nf.Response =
+  // @ts-ignore
+  Response as any;
+type _Response = nf.Response;
+const _Headers: typeof nf.Headers =
+  // @ts-ignore
+  Headers as any;
+type _Headers = nf.Headers;
+
+export const isPolyfilled = false;
+
+export { _fetch as fetch, _Request as Request, _Response as Response, _Headers as Headers };
+
+type _RequestInfo = nf.RequestInfo;
+type _RequestInit = nf.RequestInit;
+type _BodyInit = nf.BodyInit;
+
+export type { _RequestInit as RequestInit, _RequestInfo as RequestInfo, _BodyInit as BodyInit };

package/_shims/fileFromPath.node.ts

@@ -0,0 +1,30 @@
+/**
+ * Disclaimer: modules in _shims aren't intended to be imported by SDK users.
+ */
+
+import type { FilePropertyBag } from 'formdata-node';
+import { fileFromPath as _fileFromPath } from 'formdata-node/file-from-path';
+import type { File } from './formdata.node';
+
+export type FileFromPathOptions = Omit<FilePropertyBag, 'lastModified'>;
+
+let warned = false;
+
+/**
+ * @deprecated use fs.createReadStream('./my/file.txt') instead
+ */
+export async function fileFromPath(path: string): Promise<File>;
+export async function fileFromPath(path: string, filename?: string): Promise<File>;
+export async function fileFromPath(path: string, options?: FileFromPathOptions): Promise<File>;
+export async function fileFromPath(
+  path: string,
+  filename?: string,
+  options?: FileFromPathOptions,
+): Promise<File>;
+export async function fileFromPath(path: string, ...args: any[]): Promise<File> {
+  if (!warned) {
+    console.warn(`fileFromPath is deprecated; use fs.createReadStream(${JSON.stringify(path)}) instead`);
+    warned = true;
+  }
+  return await _fileFromPath(path, ...args);
+}

package/_shims/fileFromPath.ts

@@ -0,0 +1,30 @@
+/**
+ * Disclaimer: modules in _shims aren't intended to be imported by SDK users.
+ *
+ * This is a stub that gets replaced by fileFromPath.node.js for node environments
+ * in the package export map
+ */
+
+import type { FilePropertyBag } from 'formdata-node';
+import type { File } from './formdata';
+
+export type FileFromPathOptions = Omit<FilePropertyBag, 'lastModified'>;
+
+/**
+ * This is a stub for non-node environments that just throws an error.
+ * In node environments, this module will be replaced by util/node/fileFromPath by the
+ * package import map.
+ */
+export async function fileFromPath(path: string): Promise<File>;
+export async function fileFromPath(path: string, filename?: string): Promise<File>;
+export async function fileFromPath(path: string, options?: FileFromPathOptions): Promise<File>;
+export async function fileFromPath(
+  path: string,
+  filename?: string,
+  options?: FileFromPathOptions,
+): Promise<File>;
+export async function fileFromPath(): Promise<File> {
+  throw new Error(
+    'The `fileFromPath` function is only supported in Node. See the README for more details: https://www.github.com/openai/openai-node#file-uploads',
+  );
+}

package/_shims/formdata.node.ts

@@ -0,0 +1,9 @@
+/**
+ * Disclaimer: modules in _shims aren't intended to be imported by SDK users.
+ */
+
+import { FormData, File, Blob } from 'formdata-node';
+
+export { FormData, File, Blob };
+
+export const isPolyfilled = true;

package/_shims/formdata.ts

@@ -0,0 +1,22 @@
+/**
+ * Disclaimer: modules in _shims aren't intended to be imported by SDK users.
+ */
+
+import type * as fd from 'formdata-node';
+
+const _FormData: typeof fd.FormData =
+  // @ts-ignore
+  FormData as any;
+type _FormData = fd.FormData;
+const _File: typeof fd.File =
+  // @ts-ignore
+  File as any;
+type _File = fd.File;
+const _Blob: typeof fd.Blob =
+  // @ts-ignore
+  Blob as any;
+type _Blob = fd.Blob;
+
+export const isPolyfilled = false;
+
+export { _FormData as FormData, _File as File, _Blob as Blob };

package/_shims/getMultipartRequestOptions.node.ts

@@ -0,0 +1,24 @@
+/**
+ * Disclaimer: modules in _shims aren't intended to be imported by SDK users.
+ */
+
+import { FormData } from './formdata.node';
+import type { RequestOptions } from '../core';
+import { Readable } from 'node:stream';
+import { FormDataEncoder } from 'form-data-encoder';
+
+export async function getMultipartRequestOptions<T extends {} = Record<string, unknown>>(
+  form: FormData,
+  opts: RequestOptions<T>,
+): Promise<RequestOptions<T>> {
+  const encoder = new FormDataEncoder(form);
+  const readable = Readable.from(encoder);
+  const body = { __multipartBody__: readable };
+  const headers = {
+    ...opts.headers,
+    ...encoder.headers,
+    'Content-Length': encoder.contentLength,
+  };
+
+  return { ...opts, body: body as any, headers };
+}

package/_shims/getMultipartRequestOptions.ts

@@ -0,0 +1,13 @@
+/**
+ * Disclaimer: modules in _shims aren't intended to be imported by SDK users.
+ */
+
+import { FormData } from './formdata';
+import type { RequestOptions } from '../core';
+
+export async function getMultipartRequestOptions<T extends {} = Record<string, unknown>>(
+  form: FormData,
+  opts: RequestOptions<T>,
+): Promise<RequestOptions<T>> {
+  return { ...opts, body: { __multipartBody__: form } as any };
+}

package/_shims/newFileArgs.ts

@@ -0,0 +1,94 @@
+/**
+ * Disclaimer: modules in _shims aren't intended to be imported by SDK users.
+ */
+
+import { type BlobPart, type Uploadable, isResponseLike, isBlobLike } from './uploadable';
+
+export type ToFileInput = Uploadable | Exclude<BlobPart, string> | AsyncIterable<BlobPart>;
+
+export type FilePropertyBag = {
+  type?: string;
+  lastModified?: number;
+};
+
+export async function newFileArgs(
+  value: ToFileInput,
+  name?: string | null,
+  options: FilePropertyBag = {},
+): Promise<{
+  bits: BlobPart[];
+  name: string;
+  options: FilePropertyBag;
+}> {
+  if (isResponseLike(value)) {
+    const blob = await value.blob();
+    name ||= new URL(value.url).pathname.split(/[\\/]/).pop() ?? 'unknown_file';
+
+    return { bits: [blob as any], name, options };
+  }
+
+  const bits = await getBytes(value);
+
+  name ||= getName(value) ?? 'unknown_file';
+
+  if (!options.type) {
+    const type = (bits[0] as any)?.type;
+    if (typeof type === 'string') {
+      options = { ...options, type };
+    }
+  }
+
+  return { bits, name, options };
+}
+
+async function getBytes(value: ToFileInput): Promise<Array<BlobPart>> {
+  if (value instanceof Promise) return getBytes(await (value as any));
+
+  let parts: Array<BlobPart> = [];
+  if (
+    typeof value === 'string' ||
+    ArrayBuffer.isView(value) || // includes Uint8Array, Buffer, etc.
+    value instanceof ArrayBuffer
+  ) {
+    parts.push(value);
+  } else if (isBlobLike(value)) {
+    parts.push(await value.arrayBuffer());
+  } else if (
+    isAsyncIterableIterator(value) // includes Readable, ReadableStream, etc.
+  ) {
+    for await (const chunk of value) {
+      parts.push(chunk as BlobPart); // TODO, consider validating?
+    }
+  } else {
+    throw new Error(
+      `Unexpected data type: ${typeof value}; constructor: ${
+        value?.constructor?.name
+      }; props: ${propsForError(value)}`,
+    );
+  }
+
+  return parts;
+}
+
+function propsForError(value: any): string {
+  const props = Object.getOwnPropertyNames(value);
+  return `[${props.map((p) => `"${p}"`).join(', ')}]`;
+}
+
+function getName(value: any): string | undefined {
+  return (
+    getStringFromMaybeBuffer(value.name) ||
+    getStringFromMaybeBuffer(value.filename) ||
+    // For fs.ReadStream
+    getStringFromMaybeBuffer(value.path)?.split(/[\\/]/).pop()
+  );
+}
+
+const getStringFromMaybeBuffer = (x: string | Buffer | unknown): string | undefined => {
+  if (typeof x === 'string') return x;
+  if (typeof Buffer !== 'undefined' && x instanceof Buffer) return String(x);
+  return undefined;
+};
+
+const isAsyncIterableIterator = (value: any): value is AsyncIterableIterator<unknown> =>
+  value != null && typeof value === 'object' && typeof value[Symbol.asyncIterator] === 'function';

package/_shims/toFile.node.ts

@@ -0,0 +1,25 @@
+/**
+ * Disclaimer: modules in _shims aren't intended to be imported by SDK users.
+ */
+
+import { File } from 'formdata-node';
+import { type ToFileInput, newFileArgs, type FilePropertyBag } from './newFileArgs';
+import type { Uploadable, BlobPart, FileLike } from './uploadable.node'; // eslint-disable-line
+
+/**
+ * Helper for creating a {@link File} to pass to an SDK upload method from a variety of different data formats
+ * @param bits the raw content of the file.  Can be an {@link Uploadable}, {@link BlobPart}, or {@link AsyncIterable} of {@link BlobPart}s
+ * @param name the name of the file. If omitted, toFile will try to determine a file name from bits if possible
+ * @param {Object=} options additional properties
+ * @param {string=} options.type the MIME type of the content
+ * @param {number=} options.lastModified the last modified timestamp
+ * @returns a {@link File} with the given properties
+ */
+export async function toFile(
+  bits: ToFileInput,
+  name?: string | null | undefined,
+  options: FilePropertyBag | undefined = {},
+): Promise<FileLike> {
+  const args = await newFileArgs(bits, name, options);
+  return new File(args.bits, args.name, args.options);
+}

package/_shims/toFile.ts

@@ -0,0 +1,26 @@
+/// <reference lib="dom" />;
+
+/**
+ * Disclaimer: modules in _shims aren't intended to be imported by SDK users.
+ */
+
+import { type ToFileInput, newFileArgs, type FilePropertyBag } from './newFileArgs';
+import type { FileLike, Uploadable } from './uploadable'; // eslint-disable-line
+
+/**
+ * Helper for creating a {@link File} to pass to an SDK upload method from a variety of different data formats
+ * @param bits the raw content of the file.  Can be an {@link Uploadable}, {@link BlobPart}, or {@link AsyncIterable} of {@link BlobPart}s
+ * @param {string=} name the name of the file. If omitted, toFile will try to determine a file name from bits if possible
+ * @param {Object=} options additional properties
+ * @param {string=} options.type the MIME type of the content
+ * @param {number=} options.lastModified the last modified timestamp
+ * @returns a {@link File} with the given properties
+ */
+export async function toFile(
+  bits: ToFileInput,
+  name?: string | null | undefined,
+  options: FilePropertyBag | undefined = {},
+): Promise<FileLike> {
+  const args = await newFileArgs(bits, name, options);
+  return new File(args.bits as BlobPart[], args.name, args.options);
+}

package/_shims/uploadable.node.ts

@@ -0,0 +1,21 @@
+/**
+ * Disclaimer: modules in _shims aren't intended to be imported by SDK users.
+ */
+
+import { ReadStream } from 'node:fs';
+import {
+  BlobPart,
+  Uploadable,
+  BlobLike,
+  FileLike,
+  ResponseLike,
+  isBlobLike,
+  isFileLike,
+  isResponseLike,
+} from './uploadable';
+
+export { BlobPart, BlobLike, FileLike, ResponseLike, isBlobLike, Uploadable };
+
+export const isUploadable = (value: any): value is Uploadable => {
+  return isFileLike(value) || isResponseLike(value) || value instanceof ReadStream;
+};

package/_shims/uploadable.ts

@@ -0,0 +1,82 @@
+/**
+ * Disclaimer: modules in _shims aren't intended to be imported by SDK users.
+ */
+
+import type * as fs from 'node:fs';
+import type { toFile } from 'openai/_shims/toFile'; // eslint-disable-line
+
+export type BlobPart = string | ArrayBuffer | ArrayBufferView | BlobLike | Uint8Array | DataView;
+
+/**
+ * Typically, this is a native "File" class.
+ *
+ * We provide the {@link toFile} utility to convert a variety of objects
+ * into the File class.
+ *
+ * For convenience, you can also pass a fetch Response
+ * or, on Node, the result of {@link fs.createReadStream}('./myfile').
+ */
+export type Uploadable = FileLike | ResponseLike | fs.ReadStream;
+
+/**
+ * Intended to match web.Blob, node.Blob, node-fetch.Blob, etc.
+ */
+export interface BlobLike {
+  /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/Blob/size) */
+  readonly size: number;
+  /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/Blob/type) */
+  readonly type: string;
+  /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/Blob/text) */
+  text(): Promise<string>;
+  /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/Blob/slice) */
+  slice(start?: number, end?: number): BlobLike;
+  // unfortunately @types/node-fetch@^2.6.4 doesn't type the arrayBuffer method
+}
+
+/**
+ * Intended to match web.File, node.File, node-fetch.File, etc.
+ */
+export interface FileLike extends BlobLike {
+  /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/File/lastModified) */
+  readonly lastModified: number;
+  /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/File/name) */
+  readonly name: string;
+}
+
+/**
+ * Intended to match web.Response, node.Response, node-fetch.Response, etc.
+ */
+export interface ResponseLike {
+  url: string;
+  blob(): Promise<BlobLike>;
+}
+
+export const isResponseLike = (value: any): value is ResponseLike =>
+  value != null &&
+  typeof value === 'object' &&
+  typeof value.url === 'string' &&
+  typeof value.blob === 'function';
+
+export const isFileLike = (value: any): value is FileLike =>
+  value != null &&
+  typeof value === 'object' &&
+  typeof value.name === 'string' &&
+  typeof value.lastModified === 'number' &&
+  isBlobLike(value);
+
+/**
+ * The BlobLike type omits arrayBuffer() because @types/node-fetch@^2.6.4 lacks it; but this check
+ * adds the arrayBuffer() method type because it is available and used at runtime
+ */
+export const isBlobLike = (value: any): value is BlobLike & { arrayBuffer(): Promise<ArrayBuffer> } =>
+  value != null &&
+  typeof value === 'object' &&
+  typeof value.size === 'number' &&
+  typeof value.type === 'string' &&
+  typeof value.text === 'function' &&
+  typeof value.slice === 'function' &&
+  typeof value.arrayBuffer === 'function';
+
+export const isUploadable = (value: any): value is Uploadable => {
+  return isFileLike(value) || isResponseLike(value);
+};