address feedback

Author: deyaaeldeen

src/azure.ts

@@ -109,10 +109,8 @@ export class AzureOpenAI extends OpenAI {
     }
 
     super({
-      apiKey,
+      apiKey: azureADTokenProvider ?? apiKey,
       baseURL,
-      tokenProvider:
-        !azureADTokenProvider ? undefined : async () => ({ token: await azureADTokenProvider() }),
       ...opts,
       ...(dangerouslyAllowBrowser !== undefined ? { dangerouslyAllowBrowser } : {}),
     });

src/beta/realtime/websocket.ts

@@ -39,8 +39,9 @@ export class OpenAIRealtimeWebSocket extends OpenAIRealtimeEmitter {
     const dangerouslyAllowBrowser =
       props.dangerouslyAllowBrowser ??
       (client as any)?._options?.dangerouslyAllowBrowser ??
-      (client?.apiKey.startsWith('ek_') ? true : null);
-
+      (typeof (client as any)?._options?.apiKey === 'string' && client?.apiKey?.startsWith('ek_') ?
+        true
+      : null);
     if (!dangerouslyAllowBrowser && isRunningInBrowser()) {
       throw new OpenAIError(
         "It looks like you're running in a browser-like environment.\n\nThis is disabled by default, as it risks exposing your secret API credentials to attackers.\n\nYou can avoid this error by creating an ephemeral session token:\nhttps://platform.openai.com/docs/api-reference/realtime-sessions\n",
@@ -49,6 +50,10 @@ export class OpenAIRealtimeWebSocket extends OpenAIRealtimeEmitter {
 
     client ??= new OpenAI({ dangerouslyAllowBrowser });
 
+    if (typeof (client as any)?._options?.apiKey !== 'string') {
+      throw new Error('Call the create method instead to construct the client');
+    }
+
     this.url = buildRealtimeURL(client, props.model);
     props.onURL?.(this.url);
 
@@ -95,18 +100,18 @@ export class OpenAIRealtimeWebSocket extends OpenAIRealtimeEmitter {
   }
 
   static async create(
-    client: Pick<OpenAI, 'apiKey' | 'baseURL' | '_setToken'>,
+    client: Pick<OpenAI, 'apiKey' | 'baseURL' | '_setApiKey'>,
     props: { model: string; dangerouslyAllowBrowser?: boolean },
   ): Promise<OpenAIRealtimeWebSocket> {
-    await client._setToken();
+    await client._setApiKey();
     return new OpenAIRealtimeWebSocket(props, client);
   }
 
   static async azure(
-    client: Pick<AzureOpenAI, '_setToken' | 'apiVersion' | 'apiKey' | 'baseURL' | 'deploymentName'>,
+    client: Pick<AzureOpenAI, '_setApiKey' | 'apiVersion' | 'apiKey' | 'baseURL' | 'deploymentName'>,
     options: { deploymentName?: string; dangerouslyAllowBrowser?: boolean } = {},
   ): Promise<OpenAIRealtimeWebSocket> {
-    const isToken = await client._setToken();
+    const isToken = await client._setApiKey();
     function onURL(url: URL) {
       if (isToken) {
         url.searchParams.set('Authorization', `Bearer ${client.apiKey}`);

src/beta/realtime/ws.ts

@@ -13,7 +13,9 @@ export class OpenAIRealtimeWS extends OpenAIRealtimeEmitter {
   ) {
     super();
     client ??= new OpenAI();
-
+    if (typeof (client as any)._options.apiKey !== 'string') {
+      throw new Error('Call the create method instead to construct the client');
+    }
     this.url = buildRealtimeURL(client, props.model);
     this.socket = new WS.WebSocket(this.url, {
       ...props.options,
@@ -52,15 +54,15 @@ export class OpenAIRealtimeWS extends OpenAIRealtimeEmitter {
   }
 
   static async create(
-    client: Pick<OpenAI, 'apiKey' | 'baseURL' | '_setToken'>,
+    client: Pick<OpenAI, 'apiKey' | 'baseURL' | '_setApiKey'>,
     props: { model: string; options?: WS.ClientOptions | undefined },
   ): Promise<OpenAIRealtimeWS> {
-    await client._setToken();
+    await client._setApiKey();
     return new OpenAIRealtimeWS(props, client);
   }
 
   static async azure(
-    client: Pick<AzureOpenAI, '_setToken' | 'apiVersion' | 'apiKey' | 'baseURL' | 'deploymentName'>,
+    client: Pick<AzureOpenAI, '_setApiKey' | 'apiVersion' | 'apiKey' | 'baseURL' | 'deploymentName'>,
     options: { deploymentName?: string; options?: WS.ClientOptions | undefined } = {},
   ): Promise<OpenAIRealtimeWS> {
     const deploymentName = options.deploymentName ?? client.deploymentName;
@@ -90,8 +92,8 @@ export class OpenAIRealtimeWS extends OpenAIRealtimeEmitter {
   }
 }
 
-async function getAzureHeaders(client: Pick<AzureOpenAI, '_setToken' | 'apiKey'>) {
-  const isToken = await client._setToken();
+async function getAzureHeaders(client: Pick<AzureOpenAI, '_setApiKey' | 'apiKey'>) {
+  const isToken = await client._setApiKey();
   if (isToken) {
     return { Authorization: `Bearer ${isToken}` };
   } else {

src/client.ts

@@ -206,20 +206,13 @@ import {
 } from './internal/utils/log';
 import { isEmptyObj } from './internal/utils/values';
 
-export interface AccessToken {
-  token: string;
-}
-export type TokenProvider = () => Promise<AccessToken>;
+export type ApiKeySetter = () => Promise<string>;
 
 export interface ClientOptions {
   /**
    * Defaults to process.env['OPENAI_API_KEY'].
    */
-  apiKey?: string | undefined;
-  /**
-   * A function that returns a token to use for authentication.
-   */
-  tokenProvider?: TokenProvider | undefined;
+  apiKey?: string | ApiKeySetter | undefined;
   /**
    * Defaults to process.env['OPENAI_ORG_ID'].
    */
@@ -330,7 +323,6 @@ export class OpenAI {
   #encoder: Opts.RequestEncoder;
   protected idempotencyHeader?: string;
   private _options: ClientOptions;
-  private _tokenProvider: TokenProvider | undefined;
 
   /**
    * API Client for interfacing with the OpenAI API.
@@ -354,18 +346,11 @@ export class OpenAI {
     organization = readEnv('OPENAI_ORG_ID') ?? null,
     project = readEnv('OPENAI_PROJECT_ID') ?? null,
     webhookSecret = readEnv('OPENAI_WEBHOOK_SECRET') ?? null,
-    tokenProvider,
     ...opts
   }: ClientOptions = {}) {
-    if (apiKey === undefined && !tokenProvider) {
-      throw new Errors.OpenAIError(
-        'Missing credentials. Please pass one of `apiKey` and `tokenProvider`, or set the `OPENAI_API_KEY` environment variable.',
-      );
-    }
-
-    if (tokenProvider && apiKey) {
+    if (apiKey === undefined) {
       throw new Errors.OpenAIError(
-        'The `apiKey` and `tokenProvider` arguments are mutually exclusive; only one can be passed at a time.',
+        'Missing credentials. Please pass an `apiKey`, or set the `OPENAI_API_KEY` environment variable.',
       );
     }
 
@@ -374,7 +359,6 @@ export class OpenAI {
       organization,
       project,
       webhookSecret,
-      tokenProvider,
       ...opts,
       baseURL: baseURL || `https://api.openai.com/v1`,
     };
@@ -402,8 +386,7 @@ export class OpenAI {
 
     this._options = options;
 
-    this.apiKey = apiKey ?? 'Missing Key';
-    this._tokenProvider = tokenProvider;
+    this.apiKey = typeof apiKey === 'string' ? apiKey : 'Missing Key';
     this.organization = organization;
     this.project = project;
     this.webhookSecret = webhookSecret;
@@ -423,7 +406,6 @@ export class OpenAI {
       fetch: this.fetch,
       fetchOptions: this.fetchOptions,
       apiKey: this.apiKey,
-      tokenProvider: this._tokenProvider,
       organization: this.organization,
       project: this.project,
       webhookSecret: this.webhookSecret,
@@ -472,23 +454,24 @@ export class OpenAI {
     return Errors.APIError.generate(status, error, message, headers);
   }
 
-  async _setToken(): Promise<boolean> {
-    if (typeof this._tokenProvider === 'function') {
+  async _setApiKey(): Promise<boolean> {
+    const apiKey = this._options.apiKey;
+    if (typeof apiKey === 'function') {
       try {
-        const token = await this._tokenProvider();
-        if (!token || typeof token.token !== 'string') {
+        const token = await apiKey();
+        if (!token || typeof token !== 'string') {
           throw new Errors.OpenAIError(
-            `Expected 'tokenProvider' argument to return a string but it returned ${token}`,
+            `Expected 'apiKey' function argument to return a string but it returned ${token}`,
           );
         }
-        this.apiKey = token.token;
+        this.apiKey = token;
         return true;
       } catch (err: any) {
         if (err instanceof Errors.OpenAIError) {
           throw err;
         }
         throw new Errors.OpenAIError(
-          `Failed to get token from 'tokenProvider' function: ${err.message}`,
+          `Failed to get token from 'apiKey' function: ${err.message}`,
           // @ts-ignore
           { cause: err },
         );
@@ -524,7 +507,7 @@ export class OpenAI {
    * Used as a callback for mutating the given `FinalRequestOptions` object.
    */
   protected async prepareOptions(options: FinalRequestOptions): Promise<void> {
-    await this._setToken();
+    await this._setApiKey();
   }
 
   /**

tests/index.test.ts

@@ -736,7 +736,7 @@ describe('retries', () => {
       };
       const client = new OpenAI({
         baseURL: 'http://localhost:5000/',
-        tokenProvider: async () => ({ token: 'my token' }),
+        apiKey: async () => 'my token',
         fetch: testFetch,
       });
       expect(
@@ -763,12 +763,12 @@ describe('retries', () => {
         });
       };
       let counter = 0;
-      async function tokenProvider() {
-        return { token: `token-${counter++}` };
+      async function apiKey() {
+        return `token-${counter++}`;
       }
       const client = new OpenAI({
         baseURL: 'http://localhost:5000/',
-        tokenProvider,
+        apiKey,
         fetch: testFetch,
       });
       expect(
@@ -783,21 +783,6 @@ describe('retries', () => {
       ).toEqual('Bearer token-1');
     });
 
-    test('mutual exclusive', () => {
-      try {
-        new OpenAI({
-          baseURL: 'http://localhost:5000/',
-          tokenProvider: async () => ({ token: 'my token' }),
-          apiKey: 'my api key',
-        });
-      } catch (error: any) {
-        expect(error).toBeInstanceOf(Error);
-        expect(error.message).toEqual(
-          'The `apiKey` and `tokenProvider` arguments are mutually exclusive; only one can be passed at a time.',
-        );
-      }
-    });
-
     test('at least one', () => {
       try {
         new OpenAI({