openai 4.78.1 → 4.79.0

package/src/index.ts

@@ -137,7 +137,7 @@ export interface ClientOptions {
    * Note that request timeouts are retried by default, so in a worst-case scenario you may wait
    * much longer than this timeout before the promise succeeds or fails.
    */
-  timeout?: number;
+  timeout?: number | undefined;
 
   /**
    * An HTTP agent used to manage HTTP(S) connections.
@@ -145,7 +145,7 @@ export interface ClientOptions {
    * If not provided, an agent will be constructed by default in the Node.js environment,
    * otherwise no agent is used.
    */
-  httpAgent?: Agent;
+  httpAgent?: Agent | undefined;
 
   /**
    * Specify a custom `fetch` function implementation.
@@ -161,7 +161,7 @@ export interface ClientOptions {
    *
    * @default 2
    */
-  maxRetries?: number;
+  maxRetries?: number | undefined;
 
   /**
    * Default headers to include with every request to the API.
@@ -169,7 +169,7 @@ export interface ClientOptions {
    * These can be removed in individual requests by explicitly setting the
    * header to `undefined` or `null` in request options.
    */
-  defaultHeaders?: Core.Headers;
+  defaultHeaders?: Core.Headers | undefined;
 
   /**
    * Default query parameters to include with every request to the API.
@@ -177,13 +177,13 @@ export interface ClientOptions {
    * These can be removed in individual requests by explicitly setting the
    * param to `undefined` in request options.
    */
-  defaultQuery?: Core.DefaultQuery;
+  defaultQuery?: Core.DefaultQuery | undefined;
 
   /**
    * By default, client-side use of this library is not allowed, as it risks exposing your secret API credentials to attackers.
    * Only set this option to `true` if you understand the risks and have appropriate mitigations in place.
    */
-  dangerouslyAllowBrowser?: boolean;
+  dangerouslyAllowBrowser?: boolean | undefined;
 }
 
 /**

package/src/lib/EventEmitter.ts

@@ -0,0 +1,98 @@
+type EventListener<Events, EventType extends keyof Events> = Events[EventType];
+
+type EventListeners<Events, EventType extends keyof Events> = Array<{
+  listener: EventListener<Events, EventType>;
+  once?: boolean;
+}>;
+
+export type EventParameters<Events, EventType extends keyof Events> = {
+  [Event in EventType]: EventListener<Events, EventType> extends (...args: infer P) => any ? P : never;
+}[EventType];
+
+export class EventEmitter<EventTypes extends Record<string, (...args: any) => any>> {
+  #listeners: {
+    [Event in keyof EventTypes]?: EventListeners<EventTypes, Event>;
+  } = {};
+
+  /**
+   * Adds the listener function to the end of the listeners array for the event.
+   * No checks are made to see if the listener has already been added. Multiple calls passing
+   * the same combination of event and listener will result in the listener being added, and
+   * called, multiple times.
+   * @returns this, so that calls can be chained
+   */
+  on<Event extends keyof EventTypes>(event: Event, listener: EventListener<EventTypes, Event>): this {
+    const listeners: EventListeners<EventTypes, Event> =
+      this.#listeners[event] || (this.#listeners[event] = []);
+    listeners.push({ listener });
+    return this;
+  }
+
+  /**
+   * Removes the specified listener from the listener array for the event.
+   * off() will remove, at most, one instance of a listener from the listener array. If any single
+   * listener has been added multiple times to the listener array for the specified event, then
+   * off() must be called multiple times to remove each instance.
+   * @returns this, so that calls can be chained
+   */
+  off<Event extends keyof EventTypes>(event: Event, listener: EventListener<EventTypes, Event>): this {
+    const listeners = this.#listeners[event];
+    if (!listeners) return this;
+    const index = listeners.findIndex((l) => l.listener === listener);
+    if (index >= 0) listeners.splice(index, 1);
+    return this;
+  }
+
+  /**
+   * Adds a one-time listener function for the event. The next time the event is triggered,
+   * this listener is removed and then invoked.
+   * @returns this, so that calls can be chained
+   */
+  once<Event extends keyof EventTypes>(event: Event, listener: EventListener<EventTypes, Event>): this {
+    const listeners: EventListeners<EventTypes, Event> =
+      this.#listeners[event] || (this.#listeners[event] = []);
+    listeners.push({ listener, once: true });
+    return this;
+  }
+
+  /**
+   * This is similar to `.once()`, but returns a Promise that resolves the next time
+   * the event is triggered, instead of calling a listener callback.
+   * @returns a Promise that resolves the next time given event is triggered,
+   * or rejects if an error is emitted.  (If you request the 'error' event,
+   * returns a promise that resolves with the error).
+   *
+   * Example:
+   *
+   *   const message = await stream.emitted('message') // rejects if the stream errors
+   */
+  emitted<Event extends keyof EventTypes>(
+    event: Event,
+  ): Promise<
+    EventParameters<EventTypes, Event> extends [infer Param] ? Param
+    : EventParameters<EventTypes, Event> extends [] ? void
+    : EventParameters<EventTypes, Event>
+  > {
+    return new Promise((resolve, reject) => {
+      // TODO: handle errors
+      this.once(event, resolve as any);
+    });
+  }
+
+  protected _emit<Event extends keyof EventTypes>(
+    this: EventEmitter<EventTypes>,
+    event: Event,
+    ...args: EventParameters<EventTypes, Event>
+  ) {
+    const listeners: EventListeners<EventTypes, Event> | undefined = this.#listeners[event];
+    if (listeners) {
+      this.#listeners[event] = listeners.filter((l) => !l.once) as any;
+      listeners.forEach(({ listener }: any) => listener(...(args as any)));
+    }
+  }
+
+  protected _hasListener(event: keyof EventTypes): boolean {
+    const listeners = this.#listeners[event];
+    return listeners && listeners.length > 0;
+  }
+}

package/src/resources/beta/beta.ts

@@ -48,7 +48,7 @@ import {
   OtherFileChunkingStrategyObject,
   StaticFileChunkingStrategy,
   StaticFileChunkingStrategyObject,
-  StaticFileChunkingStrategyParam,
+  StaticFileChunkingStrategyObjectParam,
   VectorStore,
   VectorStoreCreateParams,
   VectorStoreDeleted,
@@ -85,7 +85,7 @@ export declare namespace Beta {
     type OtherFileChunkingStrategyObject as OtherFileChunkingStrategyObject,
     type StaticFileChunkingStrategy as StaticFileChunkingStrategy,
     type StaticFileChunkingStrategyObject as StaticFileChunkingStrategyObject,
-    type StaticFileChunkingStrategyParam as StaticFileChunkingStrategyParam,
+    type StaticFileChunkingStrategyObjectParam as StaticFileChunkingStrategyObjectParam,
     type VectorStore as VectorStore,
     type VectorStoreDeleted as VectorStoreDeleted,
     VectorStoresPage as VectorStoresPage,

package/src/resources/beta/index.ts

@@ -46,7 +46,7 @@ export {
   type OtherFileChunkingStrategyObject,
   type StaticFileChunkingStrategy,
   type StaticFileChunkingStrategyObject,
-  type StaticFileChunkingStrategyParam,
+  type StaticFileChunkingStrategyObjectParam,
   type VectorStore,
   type VectorStoreDeleted,
   type VectorStoreCreateParams,

package/src/resources/beta/vector-stores/index.ts

@@ -23,7 +23,7 @@ export {
   type OtherFileChunkingStrategyObject,
   type StaticFileChunkingStrategy,
   type StaticFileChunkingStrategyObject,
-  type StaticFileChunkingStrategyParam,
+  type StaticFileChunkingStrategyObjectParam,
   type VectorStore,
   type VectorStoreDeleted,
   type VectorStoreCreateParams,

package/src/resources/beta/vector-stores/vector-stores.ts

@@ -116,7 +116,7 @@ export type FileChunkingStrategy = StaticFileChunkingStrategyObject | OtherFileC
  * The chunking strategy used to chunk the file(s). If not set, will use the `auto`
  * strategy. Only applicable if `file_ids` is non-empty.
  */
-export type FileChunkingStrategyParam = AutoFileChunkingStrategyParam | StaticFileChunkingStrategyParam;
+export type FileChunkingStrategyParam = AutoFileChunkingStrategyParam | StaticFileChunkingStrategyObjectParam;
 
 /**
  * This is returned when the chunking strategy is unknown. Typically, this is
@@ -154,7 +154,7 @@ export interface StaticFileChunkingStrategyObject {
   type: 'static';
 }
 
-export interface StaticFileChunkingStrategyParam {
+export interface StaticFileChunkingStrategyObjectParam {
   static: StaticFileChunkingStrategy;
 
   /**
@@ -397,7 +397,7 @@ export declare namespace VectorStores {
     type OtherFileChunkingStrategyObject as OtherFileChunkingStrategyObject,
     type StaticFileChunkingStrategy as StaticFileChunkingStrategy,
     type StaticFileChunkingStrategyObject as StaticFileChunkingStrategyObject,
-    type StaticFileChunkingStrategyParam as StaticFileChunkingStrategyParam,
+    type StaticFileChunkingStrategyObjectParam as StaticFileChunkingStrategyObjectParam,
     type VectorStore as VectorStore,
     type VectorStoreDeleted as VectorStoreDeleted,
     VectorStoresPage as VectorStoresPage,

package/src/version.ts

@@ -1 +1 @@
-export const VERSION = '4.78.1'; // x-release-please-version
+export const VERSION = '4.79.0'; // x-release-please-version

package/version.d.ts

@@ -1,2 +1,2 @@
-export declare const VERSION = "4.78.1";
+export declare const VERSION = "4.79.0";
 //# sourceMappingURL=version.d.ts.map

package/version.js

@@ -1,5 +1,5 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.VERSION = void 0;
-exports.VERSION = '4.78.1'; // x-release-please-version
+exports.VERSION = '4.79.0'; // x-release-please-version
 //# sourceMappingURL=version.js.map

package/version.mjs

@@ -1,2 +1,2 @@
-export const VERSION = '4.78.1'; // x-release-please-version
+export const VERSION = '4.79.0'; // x-release-please-version
 //# sourceMappingURL=version.mjs.map