v4.0.0

Author: schnerd

api.md

@@ -60,7 +60,7 @@ Methods:
 - <code title="get /files/{file_id}">client.files.<a href="./src/resources/files.ts">retrieve</a>(fileId) -> FileObject</code>
 - <code title="get /files">client.files.<a href="./src/resources/files.ts">list</a>() -> FileObjectsPage</code>
 - <code title="delete /files/{file_id}">client.files.<a href="./src/resources/files.ts">del</a>(fileId) -> FileDeleted</code>
-- <code title="get /files/{file_id}/content">client.files.<a href="./src/resources/files.ts">retrieveFileContent</a>(fileId) -> string</code>
+- <code title="get /files/{file_id}/content">client.files.<a href="./src/resources/files.ts">retrieveContent</a>(fileId) -> string</code>
 
 # Images
 

ecosystem-tests/cli.ts

@@ -130,6 +130,11 @@ function parseArgs() {
         default: 1,
         description: 'number of parallel jobs to run',
       },
+      retry: {
+        type: 'number',
+        default: 0,
+        description: 'number of times to retry failing jobs',
+      },
       parallel: {
         type: 'boolean',
         default: false,
@@ -202,6 +207,7 @@ async function main() {
         while (queue.length) {
           const project = queue.shift();
           if (!project) break;
+
           let stdout, stderr;
           try {
             runningProjects.add(project);
@@ -212,6 +218,7 @@ async function main() {
                 __filename,
                 project,
                 '--skip-pack',
+                `--retry=${args.retry}`,
                 ...(args.live ? ['--live'] : []),
                 ...(args.verbose ? ['--verbose'] : []),
                 ...(args.deploy ? ['--deploy'] : []),
@@ -245,7 +252,7 @@ async function main() {
         console.error('\n');
 
         try {
-          await fn();
+          await withRetry(fn, project, state.retry)
           console.error(`✅ - Successfully ran ${project}`);
         } catch (err) {
           if (err && (err as any).shortMessage) {
@@ -268,6 +275,18 @@ async function main() {
   process.exit(0);
 }
 
+async function withRetry(fn: () => Promise<void>, identifier: string, retryAmount: number): Promise<void> {
+  do {
+    try {
+      return await fn()
+    } catch (err) {
+      console.error(`${identifier} failed due to ${err}; retries left ${retryAmount}`)
+    }
+
+    retryAmount--;
+  } while (retryAmount > 0)
+}
+
 function centerPad(text: string, width = text.length, char = ' '): string {
   return text.padStart(Math.floor((width + text.length) / 2), char).padEnd(width, char);
 }

ecosystem-tests/vercel-edge/package-lock.json

@@ -11,7 +11,7 @@
     "vercel": "vercel"
   },
   "dependencies": {
-    "ai": "2.1.9",
+    "ai": "2.1.34",
     "next": "13.4.6",
     "react": "18.2.0",
     "react-dom": "18.2.0"

ecosystem-tests/vercel-edge/package.json

@@ -1,6 +1,6 @@
 {
   "name": "openai",
-  "version": "4.0.0-beta.12",
+  "version": "4.0.0",
   "description": "Client library for the OpenAI API",
   "author": "OpenAI <support@openai.com>",
   "types": "dist/index.d.ts",

package.json

@@ -322,10 +322,10 @@ export abstract class APIClient {
     return new APIPromise(this.makeRequest(options, remainingRetries));
   }
 
-  private async makeRequest<T>(
+  private async makeRequest(
     optionsInput: PromiseOrValue<FinalRequestOptions>,
     retriesRemaining: number | null,
-  ): Promise<{ response: Response; options: FinalRequestOptions; controller: AbortController }> {
+  ): Promise<APIResponseProps> {
     const options = await optionsInput;
     if (retriesRemaining == null) {
       retriesRemaining = options.maxRetries ?? this.maxRetries;
@@ -462,11 +462,11 @@ export abstract class APIClient {
     return false;
   }
 
-  private async retryRequest<Req extends {}, Rsp>(
-    options: FinalRequestOptions<Req>,
+  private async retryRequest(
+    options: FinalRequestOptions,
     retriesRemaining: number,
     responseHeaders?: Headers | undefined,
-  ): Promise<Rsp> {
+  ): Promise<APIResponseProps> {
     retriesRemaining -= 1;
 
     // About the Retry-After header: https://developer.mozilla.org/en-US/docs/Web/HTTP/Headers/Retry-After
@@ -479,7 +479,7 @@ export abstract class APIClient {
     const timeout = this.calculateRetryTimeoutSeconds(retriesRemaining, retryAfter, maxRetries) * 1000;
     await sleep(timeout);
 
-    return this.request(options, retriesRemaining);
+    return this.makeRequest(options, retriesRemaining);
   }
 
   private calculateRetryTimeoutSeconds(

src/core.ts

@@ -76,13 +76,27 @@ export interface ClientOptions {
   organization?: string | null;
 }
 
-/** Instantiate the API Client. */
+/** API Client for interfacing with the OpenAI API. */
 export class OpenAI extends Core.APIClient {
   apiKey: string;
   organization?: string | null;
 
   private _options: ClientOptions;
 
+  /**
+   * API Client for interfacing with the OpenAI API.
+   *
+   * @param {string} [opts.apiKey=process.env['OPENAI_API_KEY']] - The API Key to send to the API.
+   * @param {string} [opts.baseURL] - Override the default base URL for the API.
+   * @param {number} [opts.timeout=10 minutes] - The maximum amount of time (in milliseconds) the client will wait for a response before timing out.
+   * @param {number} [opts.httpAgent] - An HTTP agent used to manage HTTP(s) connections.
+   * @param {Core.Fetch} [opts.fetch] - Specify a custom `fetch` function implementation.
+   * @param {number} [opts.maxRetries=2] - The maximum number of times the client will retry a request.
+   * @param {Core.Headers} opts.defaultHeaders - Default headers to include with every request to the API.
+   * @param {Core.DefaultQuery} opts.defaultQuery - Default query parameters to include with every request to the API.
+   * @param {boolean} [opts.dangerouslyAllowBrowser=false] - By default, client-side use of this library is not allowed, as it risks exposing your secret API credentials to attackers.
+   * @param {string | null} [opts.organization]
+   */
   constructor({
     apiKey = Core.readEnv('OPENAI_API_KEY'),
     organization = Core.readEnv('OPENAI_ORG_ID') ?? null,

src/index.ts

@@ -41,7 +41,7 @@ export class Files extends APIResource {
   /**
    * Returns the contents of the specified file
    */
-  retrieveFileContent(fileId: string, options?: Core.RequestOptions): Core.APIPromise<string> {
+  retrieveContent(fileId: string, options?: Core.RequestOptions): Core.APIPromise<string> {
     return this.get(`/files/${fileId}/content`, {
       ...options,
       headers: { Accept: 'application/json', ...options?.headers },

src/resources/files.ts

@@ -1 +1 @@
-export const VERSION = '4.0.0-beta.12';
+export const VERSION = '4.0.0';

src/version.ts

@@ -6,8 +6,7 @@ import { Response } from 'node-fetch';
 const openai = new OpenAI({ apiKey: 'something1234', baseURL: 'http://127.0.0.1:4010' });
 
 describe('resource files', () => {
-  // Prism tests are broken
-  test.skip('create: only required params', async () => {
+  test('create: only required params', async () => {
     const responsePromise = openai.files.create({
       file: await toFile(Buffer.from('# my file contents'), 'README.md'),
       purpose: 'string',
@@ -21,8 +20,7 @@ describe('resource files', () => {
     expect(dataAndResponse.response).toBe(rawResponse);
   });
 
-  // Prism tests are broken
-  test.skip('create: required and optional params', async () => {
+  test('create: required and optional params', async () => {
     const response = await openai.files.create({
       file: await toFile(Buffer.from('# my file contents'), 'README.md'),
       purpose: 'string',
@@ -83,9 +81,8 @@ describe('resource files', () => {
     );
   });
 
-  // Prism tests are broken
-  test.skip('retrieveFileContent', async () => {
-    const responsePromise = openai.files.retrieveFileContent('string');
+  test('retrieveContent', async () => {
+    const responsePromise = openai.files.retrieveContent('string');
     const rawResponse = await responsePromise.asResponse();
     expect(rawResponse).toBeInstanceOf(Response);
     const response = await responsePromise;
@@ -95,11 +92,10 @@ describe('resource files', () => {
     expect(dataAndResponse.response).toBe(rawResponse);
   });
 
-  // Prism tests are broken
-  test.skip('retrieveFileContent: request options instead of params are passed correctly', async () => {
+  test('retrieveContent: request options instead of params are passed correctly', async () => {
     // ensure the request options are being passed correctly by passing an invalid HTTP method in order to cause an error
     await expect(
-      openai.files.retrieveFileContent('string', { path: '/_stainless_unknown_path' }),
+      openai.files.retrieveContent('string', { path: '/_stainless_unknown_path' }),
     ).rejects.toThrow(OpenAI.NotFoundError);
   });
 });

tests/api-resources/files.test.ts

@@ -3,7 +3,7 @@
 import OpenAI from 'openai';
 import { APIUserAbortError } from 'openai';
 import { Headers } from 'openai/core';
-import { Response, fetch as defaultFetch } from 'openai/_shims/fetch';
+import { Response, fetch as defaultFetch, type RequestInit, type RequestInfo } from 'openai/_shims/fetch';
 
 describe('instantiate client', () => {
   const env = process.env;
@@ -188,3 +188,28 @@ describe('request building', () => {
     });
   });
 });
+
+describe('retries', () => {
+  test('single retry', async () => {
+    let count = 0;
+    const testFetch = async (url: RequestInfo, { signal }: RequestInit = {}): Promise<Response> => {
+      if (!count++)
+        return new Promise((resolve, reject) =>
+          signal?.addEventListener('abort', () => reject(new Error('timed out'))),
+        );
+      return new Response(JSON.stringify({ a: 1 }), { headers: { 'Content-Type': 'application/json' } });
+    };
+
+    const client = new OpenAI({ apiKey: 'my api key', timeout: 2000, fetch: testFetch });
+
+    expect(await client.request({ path: '/foo', method: 'get' })).toEqual({ a: 1 });
+    expect(count).toEqual(2);
+    expect(
+      await client
+        .request({ path: '/foo', method: 'get' })
+        .asResponse()
+        .then((r) => r.text()),
+    ).toEqual(JSON.stringify({ a: 1 }));
+    expect(count).toEqual(3);
+  }, 10000);
+});